def test_primaries_in_ordered_from_audit_for_tree_txns(test_node):
primaries = {}
replica = test_node.master_replica
test_node.primaries = ["Alpha", "Beta"]
for i in range(3):
pp = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=i)
key = (pp.viewNo, pp.ppSeqNo)
replica.prePrepares[key] = pp
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pp,
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash,
primaries=["Node{}".format(num) for num in range(i + 1)],
valid_digests=pp.reqIdr)
test_node.audit_handler.post_batch_applied(three_pc_batch)
primaries[key] = three_pc_batch.primaries
for key in reversed(list(primaries.keys())):
replica.order_3pc_key(key)
for ordered in replica.outBox:
if not isinstance(ordered, Ordered):
continue
assert ordered.primaries != test_node.primaries
assert ordered.primaries == primaries[(ordered.viewNo,
ordered.ppSeqNo)]
def tryOrderAndAddTxns(self, commit):
canOrder, _ = self.canOrder(commit)
node = replica.node
if not replica.added and canOrder:
pp = self.getPrePrepare(commit.viewNo, commit.ppSeqNo)
ledger_manager = node.ledgerManager
ledger_id = DOMAIN_LEDGER_ID
catchup_rep_service = ledger_manager._leechers[
ledger_id].catchup_rep_service
# simulate audit ledger catchup
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pp,
valid_txn_count=len(reqs),
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash)
node.audit_handler.post_batch_applied(three_pc_batch)
node.audit_handler.commit_batch(ledger_id, len(reqs),
pp.stateRootHash, pp.txnRootHash,
pp.ppTime)
ledger_manager.preCatchupClbk(ledger_id)
pp = self.getPrePrepare(commit.viewNo, commit.ppSeqNo)
for req in reqs:
txn = append_txn_metadata(reqToTxn(req), txn_time=pp.ppTime)
catchup_rep_service._add_txn(txn)
ledger_manager.catchupCompleted(DOMAIN_LEDGER_ID,
(node.viewNo, commit.ppSeqNo))
replica.added = True
return origMethod(commit)
def test_node_reg_in_ordered_from_audit_for_tree_txns(test_node):
node_regs = {}
replica = test_node.master_replica
node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
for i in range(3):
pp = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=i)
key = (pp.viewNo, pp.ppSeqNo)
replica._ordering_service.prePrepares[key] = pp
replica._consensus_data.preprepared.append(preprepare_to_batch_id(pp))
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pp,
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash,
valid_digests=pp.reqIdr)
three_pc_batch.node_reg = node_reg + ["Node{}".format(i + 10)]
three_pc_batch.primaries = ["Alpha", "Beta"]
test_node.write_manager.audit_b_handler.post_batch_applied(
three_pc_batch)
node_regs[key] = three_pc_batch.node_reg
for key in reversed(list(node_regs.keys())):
pp = replica._ordering_service.get_preprepare(*key)
assert replica._ordering_service._get_node_reg_for_ordered(
pp) == node_regs[key]
def test_node_reg_in_ordered_from_audit_no_node_reg(test_node):
replica = test_node.master_replica
# run multiple times to have a situation when we write node reg to non-empty audit ledger
for i in range(1, 4):
uncommitted_node_reg = ['Alpha', 'Beta', 'Gamma', 'Node{}'.format(i)]
test_node.write_manager.node_reg_handler.uncommitted_node_reg = uncommitted_node_reg
pre_prepare = create_pre_prepare_no_bls(
state_root=generate_state_root(), pp_seq_no=i)
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
replica._ordering_service.prePrepares[key] = pre_prepare
replica._consensus_data.preprepared.append(
preprepare_to_batch_id(pre_prepare))
test_node.primaries = ["Alpha", "Beta"]
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pre_prepare,
state_root=pre_prepare.stateRootHash,
txn_root=pre_prepare.txnRootHash,
primaries=["Alpha", "Beta", "Gamma"],
valid_digests=pre_prepare.reqIdr)
three_pc_batch.node_reg = None
test_node.write_manager.audit_b_handler.post_batch_applied(
three_pc_batch)
replica._ordering_service._order_3pc_key(key)
ordered = replica.outBox.pop()
# we expect it equal to the current uncommitted node reg
assert ordered.nodeReg == uncommitted_node_reg
def test_primaries_in_ordered_from_audit_for_tree_txns(test_node):
node_regs = {}
replica = test_node.master_replica
test_node.primaries = ["Alpha", "Beta"]
node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
for i in range(3):
pp = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=i)
key = (pp.viewNo, pp.ppSeqNo)
replica._ordering_service.prePrepares[key] = pp
replica._consensus_data.preprepared.append(preprepare_to_batch_id(pp))
three_pc_batch = ThreePcBatch.from_pre_prepare(pre_prepare=pp,
state_root=pp.stateRootHash,
txn_root=pp.txnRootHash,
primaries=["Node{}".format(num)
for num in range(i + 1)],
valid_digests=pp.reqIdr)
three_pc_batch.node_reg = node_reg + ["Node{}".format(i + 10)]
test_node.write_manager.audit_b_handler.post_batch_applied(three_pc_batch)
node_regs[key] = three_pc_batch.node_reg
for key in reversed(list(node_regs.keys())):
replica._ordering_service._order_3pc_key(key)
for ordered in replica.outBox:
if not isinstance(ordered, Ordered):
continue
assert ordered.nodeReg == node_regs[(ordered.viewNo,
ordered.ppSeqNo)]
def test_node_reg_in_ordered_from_audit(test_node):
pre_prepare = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=1)
replica = test_node.master_replica
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
replica._ordering_service.prePrepares[key] = pre_prepare
replica._consensus_data.preprepared.append(
preprepare_to_batch_id(pre_prepare))
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pre_prepare,
state_root=pre_prepare.stateRootHash,
txn_root=pre_prepare.txnRootHash,
valid_digests=pre_prepare.reqIdr)
three_pc_batch.node_reg = ["Alpha", "Beta", "Gamma", "Delta", "Eta"]
three_pc_batch.primaries = ["Alpha", "Beta"]
test_node.write_manager.audit_b_handler.post_batch_applied(three_pc_batch)
assert replica._ordering_service._get_node_reg_for_ordered(
pre_prepare) == three_pc_batch.node_reg
def test_primaries_in_ordered_from_audit(test_node):
pre_prepare = create_pre_prepare_no_bls(state_root=generate_state_root(),
pp_seq_no=1)
replica = test_node.master_replica
key = (pre_prepare.viewNo, pre_prepare.ppSeqNo)
replica.prePrepares[key] = pre_prepare
test_node.primaries = ["Alpha", "Beta"]
three_pc_batch = ThreePcBatch.from_pre_prepare(
pre_prepare=pre_prepare,
state_root=pre_prepare.stateRootHash,
txn_root=pre_prepare.txnRootHash,
primaries=["Alpha", "Beta", "Gamma"],
valid_digests=pre_prepare.reqIdr)
test_node.audit_handler.post_batch_applied(three_pc_batch)
replica.order_3pc_key(key)
ordered = replica.outBox.pop()
assert ordered.primaries != test_node.primaries
assert ordered.primaries == three_pc_batch.primaries