Beispiel #1
0
    def processLedgerStatus(self, status: LedgerStatus, frm: str):
        logger.debug("{} received ledger status: {} from {}".format(
            self, status, frm))
        if not status:
            logger.debug("{} found ledger status to be null from {}".format(
                self, frm))
            return

        # Nodes might not be using pool txn ledger, might be using simple node
        # registries (old approach)
        ledgerStatus = LedgerStatus(*status)
        if ledgerStatus.txnSeqNo < 0:
            self.discard(status,
                         reason="Received negative sequence number "
                         "from {}".format(frm),
                         logMethod=logger.warning)

        ledgerId = getattr(status, f.LEDGER_ID.nm)

        # If this is a node's ledger manager and sender of this ledger status
        #  is a client and its pool ledger is same as this node's pool ledger
        # then send the pool ledger status since client wont be receiving the
        # consistency proof in this case:
        statusFromClient = self.getStack(frm) == self.clientstack
        if self.ownedByNode and statusFromClient:
            if ledgerId != POOL_LEDGER_ID:
                logger.debug("{} received inappropriate "
                             "ledger status {} from client {}".format(
                                 self, status, frm))
                return
            if self.isLedgerSame(ledgerStatus):
                ledger_status = self.owner.build_ledger_status(POOL_LEDGER_ID)
                self.sendTo(ledger_status, frm)

        # If a ledger is yet to sync and cannot sync right now,
        # then stash the ledger status to be processed later
        ledgerInfo = self.getLedgerInfoByType(ledgerId)
        if ledgerInfo.state != LedgerState.synced and not ledgerInfo.canSync:
            self.stashLedgerStatus(ledgerId, status, frm)
            return

        # If this manager is owned by a node and this node's ledger is ahead of
        # the received ledger status
        if self.ownedByNode and self.isLedgerNew(ledgerStatus):
            consistencyProof = self.getConsistencyProof(ledgerStatus)
            if not consistencyProof:
                return None
            self.sendTo(consistencyProof, frm)

        if self.isLedgerOld(ledgerStatus):
            # if ledgerInfo.state == LedgerState.synced:
            if ledgerInfo.state != LedgerState.syncing:
                self.setLedgerCanSync(ledgerId, True)
                ledger_status = self.owner.build_ledger_status(ledgerId)
                self.sendTo(ledger_status, frm)
            return

        if statusFromClient:
            return

        # This node's ledger is not older so it will not receive a
        # consistency proof unless the other node processes a transaction
        # post sending this ledger status
        ledgerInfo.recvdConsistencyProofs[frm] = None
        ledgerInfo.ledgerStatusOk.add(frm)
        if self.has_ledger_status_quorum(len(ledgerInfo.ledgerStatusOk),
                                         self.owner.totalNodes):
            logger.debug("{} found out from {} that its "
                         "ledger of type {} is latest".format(
                             self, ledgerInfo.ledgerStatusOk, ledgerId))
            if ledgerInfo.state != LedgerState.synced:
                logger.debug('{} found from ledger status {} that it does '
                             'not need catchup'.format(self, ledgerStatus))
                # If this node's ledger is same as the ledger status (which is
                #  also the majority of the pool), then set the last ordered
                # 3PC key
                key = (ledgerStatus.viewNo, ledgerStatus.ppSeqNo)
                self.do_pre_catchup(ledgerId)
                if self.isLedgerSame(ledgerStatus) and key != (None, None):
                    # Any state cleaup that is part of pre-catchup should be
                    # done
                    self.catchupCompleted(ledgerId, key)
                else:
                    self.catchupCompleted(ledgerId)
def test_that_dir_returns_only_message_keys():
    message = LedgerStatus(
        1, 10, None, None, "AwgQhPR9cgRubttBGjRruCRMLhZFBffbejbPipj7WBBm", CURRENT_PROTOCOL_VERSION)
    assert set(dir(message)) == set(message.keys())
Beispiel #3
0
    1,
    'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
    1,
    'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
    '7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ',
)

propagate_msg = Propagate(**{'request': {'identifier': '5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC',
                                         'signature': 'ZbZG68WiaK67eU3CsgpVi85jpgCztW9Yqe7D5ezDUfWbKdiPPVbWq4Tb5m4Ur3jcR5wJ8zmBUZXZudjvMN63Aa9',
                                         'operation': {'amount': 62,
                                                       'type': 'buy'},
                                         'reqId': 1499782864169193},
                             'senderClient': '+DG1:vO9#de6?R?>:3RwdAXSdefgLLfxSoN4WMEe'})

bad_msgs = [
    (LEDGER_STATUS, {'p1': 'v1', 'p2': 'v2'}, LedgerStatus(
        1, 20, 1, 2, '77wuDUSr4FtAJzJbSqSW7bBw8bKAbra8ABSAjR72Nipq')),
    (LEDGER_STATUS, {f.LEDGER_ID.nm: 100}, LedgerStatus(
        1, 20, 1, 2, '77wuDUSr4FtAJzJbSqSW7bBw8bKAbra8ABSAjR72Nipq')),
    (CONSISTENCY_PROOF, {f.LEDGER_ID.nm: 1, f.SEQ_NO_START.nm: 10},
     ConsistencyProof(1, 2, 20, 1, 3,
                      'BvmagFYpXAYNTuNW8Qssk9tMhEEPucLqL55YuwngUvMw',
                      'Dce684wcwhV2wNZCuYTzdW9Kr13ZXFgiuAuAGibFZc4v',
                      ['58qasGZ9y3TB1pMz7ARKjJeccEbvbx6FT6g3NFnjYsTS'])),
    (PREPREPARE, {f.INST_ID.nm: 1, f.VIEW_NO.nm: 0, f.SEQ_NO_START.nm: 10},
     pre_prepare_msg),
    (PREPREPARE, {f.INST_ID.nm: -1, f.VIEW_NO.nm: 1, f.PP_SEQ_NO.nm: 10},
     pre_prepare_msg),
    (PROPAGATE, {f.IDENTIFIER.nm: 'aa', f.REQ_ID.nm: 'fr'}, propagate_msg),
    (PROPAGATE, {
        f.IDENTIFIER.nm: '4AdS22kC7xzb4bcqg9JATuCfAMNcQYcZa1u5eWzs6cSJ'}, propagate_msg),
    (PROPAGATE, {f.REQ_ID.nm: 1499707723017300}, propagate_msg),