def __init__(self, ledger_id: int, config: object, input: RxChannel,
output: TxChannel, timer: TimerService,
metrics: MetricsCollector, provider: CatchupDataProvider):
self._ledger_id = ledger_id
self._ledger = provider.ledger(ledger_id)
self._config = config
self._output = output
self._timer = timer
self.metrics = metrics
self._provider = provider
self._state = LedgerState.not_synced # TODO: Improve enum
self._catchup_till = None # type: Optional[CatchupTill]
self._num_txns_caught_up = 0
services_tx, services_rx = create_direct_channel()
router = Router(services_rx)
router.add(LedgerCatchupStart, self._on_catchup_start)
router.add(LedgerCatchupComplete, self._on_catchup_complete)
self._cons_proof_service = ConsProofService(ledger_id=ledger_id,
config=config,
input=input,
output=services_tx,
timer=self._timer,
metrics=self.metrics,
provider=self._provider)
self._catchup_rep_service = CatchupRepService(ledger_id=ledger_id,
config=config,
input=input,
output=services_tx,
timer=self._timer,
metrics=self.metrics,
provider=self._provider)
def __init__(self, ledger_id: int, config: object, input: RxChannel,
output: TxChannel, timer: TimerService,
metrics: MetricsCollector, provider: CatchupDataProvider):
router = Router(input)
router.add(LedgerStatus, self.process_ledger_status)
router.add(ConsistencyProof, self.process_consistency_proof)
self._ledger_id = ledger_id
self._ledger = provider.ledger(ledger_id)
self._config = config
self._output = output
self._timer = timer
self.metrics = metrics
self._provider = provider
self._is_working = False
self._quorum = Quorums(len(self._provider.all_nodes_names()))
self._same_ledger_status = set()
self._cons_proofs = {}
self._already_asked_for_cons_proofs_without_timeout = False
self._last_txn_3PC_key = {}
self._ledger_status_timer = \
RepeatingTimer(self._timer,
self._config.LedgerStatusTimeout * (len(self._provider.all_nodes_names()) - 1),
self._reask_for_ledger_status,
active=False)
self._consistency_proof_timer = \
RepeatingTimer(self._timer,
self._config.ConsistencyProofsTimeout * (len(self._provider.all_nodes_names()) - 1),
self._reask_for_last_consistency_proof,
active=False)
def patched_node(txnPoolNodeSet):
node = txnPoolNodeSet[0]
node_leecher = node.ledgerManager._node_leecher
router = Router(node_leecher._leecher_outbox_rx)
def patched_ledger_catchup_complete(msg):
node_leecher._output.put_nowait(NodeCatchupComplete())
router.add(LedgerCatchupComplete, patched_ledger_catchup_complete)
return node
def __init__(self,
owner,
postAllLedgersCaughtUp: Optional[Callable] = None,
preCatchupClbk: Optional[Callable] = None,
postCatchupClbk: Optional[Callable] = None,
ledger_sync_order: Optional[List] = None,
metrics: MetricsCollector = NullMetricsCollector()):
# If ledger_sync_order is not provided (is None), it is assumed that
# `postCatchupCompleteClbk` of the LedgerInfo will be used
self.owner = owner
self._timer = owner.timer
self.postAllLedgersCaughtUp = postAllLedgersCaughtUp
self.preCatchupClbk = preCatchupClbk
self.postCatchupClbk = postCatchupClbk
self.ledger_sync_order = ledger_sync_order
self.request_ledger_status_action_ids = dict()
self.request_consistency_proof_action_ids = dict()
self.metrics = metrics
self._provider = CatchupNodeDataProvider(owner)
self._client_seeder_inbox, rx = create_direct_channel()
self._client_seeder = ClientSeederService(rx, self._provider)
self._node_seeder_inbox, rx = create_direct_channel()
self._node_seeder = NodeSeederService(rx, self._provider)
self._leecher_outbox, rx = create_direct_channel()
router = Router(rx)
router.add(LedgerCatchupComplete, self._on_catchup_rep_service_stop)
router.add(ConsProofReady, self._on_cons_proof_service_stop)
self.config = getConfig()
# Holds ledgers of different types with
# their info like callbacks, state, etc
self.ledgerRegistry = {} # type: Dict[int, LedgerInfo]
self._leechers = {
} # type: Dict[int, LedgerManager.LedgerLeecherService]
# Largest 3 phase key received during catchup.
# This field is needed to discard any stashed 3PC messages or
# ordered messages since the transactions part of those messages
# will be applied when they are received through the catchup process
self.last_caught_up_3PC = (0, 0)
# Nodes are added in this set when the current node sent a CatchupReq
# for them and waits a CatchupRep message.
self.wait_catchup_rep_from = set()
def __init__(self, ledger_id: int, config: object, input: RxChannel,
output: TxChannel, timer: TimerService,
metrics: MetricsCollector, provider: CatchupDataProvider):
router = Router(input)
router.add(LedgerStatus, self.process_ledger_status)
router.add(ConsistencyProof, self.process_consistency_proof)
self._ledger_id = ledger_id
self._ledger = provider.ledger(ledger_id)
self._config = config
self._output = output
self._timer = timer
self.metrics = metrics
self._provider = provider
self._is_working = False
self._quorum = Quorums(len(self._provider.all_nodes_names()))
self._same_ledger_status = set()
self._cons_proofs = {}
self._requested_consistency_proof = set()
self._last_txn_3PC_key = {}
def __init__(self, config: object, input: RxChannel, output: TxChannel,
timer: TimerService, metrics: MetricsCollector,
provider: CatchupDataProvider):
self._config = config
self._input = input
self._output = output
self._timer = timer
self.metrics = metrics
self._provider = provider
self._state = self.State.Idle
self._catchup_till = {} # type: Dict[int, CatchupTill]
self._nodes_ledger_sizes = {} # type: Dict[int, Dict[str, int]]
# TODO: Get rid of this, theoretically most ledgers can be synced in parallel
self._current_ledger = None # type: Optional[int]
self._leecher_outbox, self._leecher_outbox_rx = create_direct_channel()
self._leecher_outbox_rx.subscribe(lambda msg: output.put_nowait(msg))
router = Router(self._leecher_outbox_rx)
router.add(LedgerCatchupStart, self._on_ledger_catchup_start)
router.add(LedgerCatchupComplete, self._on_ledger_catchup_complete)
self._leechers = {} # type: Dict[int, LedgerLeecherService]
def __init__(self,
owner,
postAllLedgersCaughtUp: Optional[Callable] = None,
preCatchupClbk: Optional[Callable] = None,
postCatchupClbk: Optional[Callable] = None,
ledger_sync_order: Optional[List] = None,
metrics: MetricsCollector = NullMetricsCollector()):
# If ledger_sync_order is not provided (is None), it is assumed that
# `postCatchupCompleteClbk` of the LedgerInfo will be used
self.owner = owner
self._timer = owner.timer
self.postAllLedgersCaughtUp = postAllLedgersCaughtUp
self.preCatchupClbk = preCatchupClbk
self.postCatchupClbk = postCatchupClbk
self.ledger_sync_order = ledger_sync_order
self.request_ledger_status_action_ids = dict()
self.request_consistency_proof_action_ids = dict()
self.metrics = metrics
config = getConfig()
provider = CatchupNodeDataProvider(owner)
self._client_seeder_inbox, rx = create_direct_channel()
self._client_seeder = ClientSeederService(rx, provider)
self._node_seeder_inbox, rx = create_direct_channel()
self._node_seeder = NodeSeederService(rx, provider)
leecher_outbox_tx, leecher_outbox_rx = create_direct_channel()
router = Router(leecher_outbox_rx)
router.add(LedgerCatchupStart, self._on_ledger_sync_start)
router.add(LedgerCatchupComplete, self._on_ledger_sync_complete)
router.add(NodeCatchupComplete, self._on_catchup_complete)
self._node_leecher_inbox, rx = create_direct_channel()
self._node_leecher = NodeLeecherService(config=config,
input=rx,
output=leecher_outbox_tx,
timer=self._timer,
metrics=self.metrics,
provider=provider)
# Holds ledgers of different types with their info like callbacks, state, etc
self.ledgerRegistry = {} # type: Dict[int, LedgerInfo]
# Largest 3 phase key received during catchup.
# This field is needed to discard any stashed 3PC messages or
# ordered messages since the transactions part of those messages
# will be applied when they are received through the catchup process
self.last_caught_up_3PC = (0, 0)
def __init__(self, input: RxChannel, provider: CatchupDataProvider):
router = Router(input)
router.add(LedgerStatus, self.process_ledger_status)
router.add(CatchupReq, self.process_catchup_req)
self._provider = provider