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 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 post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
# Observer case:
if not self.uncommitted_node_reg and three_pc_batch.node_reg:
self.uncommitted_node_reg = list(three_pc_batch.node_reg)
view_no = three_pc_batch.view_no if three_pc_batch.original_view_no is None else three_pc_batch.original_view_no
# Update active_node_reg to point to node_reg at the end of last view
if view_no > self._uncommitted_view_no:
self.uncommitted_node_reg_at_beginning_of_view[view_no] = list(
self._uncommitted[-1].uncommitted_node_reg) if len(
self._uncommitted) > 0 else list(self.committed_node_reg)
self._uncommitted_view_no = view_no
self._uncommitted.append(
UncommittedNodeReg(list(self.uncommitted_node_reg), view_no))
three_pc_batch.node_reg = list(self.uncommitted_node_reg)
logger.debug("Applied uncommitted node registry: {}".format(
self.uncommitted_node_reg))
logger.debug(
"Current committed node registry for previous views: {}".format(
sorted(self.committed_node_reg_at_beginning_of_view.items())))
logger.debug(
"Current uncommitted node registry for previous views: {}".format(
sorted(
self.uncommitted_node_reg_at_beginning_of_view.items())))
logger.debug("Current active node registry: {}".format(
self.active_node_reg))
def three_pc_batch():
return ThreePcBatch(DOMAIN_LEDGER_ID, 0, 0, 1, time.time(),
randomString(),
randomString(),
['a', 'b', 'c'],
['d1', 'd2', 'd3'],
'pp_digest')
def commit_batch(self, three_pc_batch, prev_handler_result=None):
committed_txns = prev_handler_result
token_state_root, token_txn_root, _ = self.token_tracker.commit_batch()
committed_seq_nos_with_fees = [
get_seq_no(t) for t in committed_txns
if self._fees_tracker.has_deducted_fees(get_type(t), get_seq_no(t))
]
if len(committed_seq_nos_with_fees) > 0:
# This is a fake txn only for commit to token ledger
token_fake_three_pc_batch = ThreePcBatch(
ledger_id=TOKEN_LEDGER_ID,
inst_id=three_pc_batch.inst_id,
view_no=three_pc_batch.view_no,
pp_seq_no=three_pc_batch.pp_seq_no,
pp_time=three_pc_batch.pp_time,
state_root=token_state_root,
txn_root=txn_root_serializer.serialize(token_txn_root),
primaries=three_pc_batch.primaries,
valid_digests=[
i for i in range(len(committed_seq_nos_with_fees))
])
committed_token_txns = super()._commit(self.token_ledger,
self.token_state,
token_fake_three_pc_batch)
TokenStaticHelper.commit_to_utxo_cache(self.utxo_cache,
token_state_root)
i = 0
# We are adding fees txn to the reply, so that client could get information about token transition
for txn in committed_txns:
if get_seq_no(txn) in committed_seq_nos_with_fees:
txn[FEES] = committed_token_txns[i]
i += 1
self._fees_tracker.fees_in_current_batch = 0
return committed_txns
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 add_txns_to_audit(alh,
count,
ledger_id,
txns_per_batch,
view_no,
initial_pp_seq_no,
pp_time,
digest=''):
db_manager = alh.database_manager
for i in range(count):
add_txns(db_manager, ledger_id, txns_per_batch, pp_time)
three_pc_batch = ThreePcBatch(
ledger_id=ledger_id,
inst_id=0,
view_no=view_no,
pp_seq_no=initial_pp_seq_no + i,
pp_time=pp_time,
state_root=db_manager.get_state(ledger_id).headHash,
txn_root=db_manager.get_ledger(ledger_id).uncommitted_root_hash,
primaries=DEFAULT_PRIMARIES,
node_reg=DEFAULT_NODE_REG,
valid_digests=[],
pp_digest=digest)
alh._add_to_ledger(three_pc_batch)
alh.ledger.commitTxns(count)
def do_apply_audit_txn(alh,
txns_count,
ledger_id,
view_no,
pp_sq_no,
txn_time,
has_audit_txn=True,
original_view_no=None,
digest='',
nod_reg=DEFAULT_NODE_REG):
db_manager = alh.database_manager
add_txns(db_manager, ledger_id, txns_count, txn_time)
three_pc_batch = ThreePcBatch(
ledger_id=ledger_id,
inst_id=0,
view_no=view_no,
pp_seq_no=pp_sq_no,
pp_time=txn_time,
state_root=db_manager.get_state(ledger_id).headHash,
txn_root=db_manager.get_ledger(ledger_id).uncommitted_root_hash,
primaries=DEFAULT_PRIMARIES,
valid_digests=[],
pp_digest=digest,
node_reg=nod_reg,
has_audit_txn=has_audit_txn,
original_view_no=original_view_no)
alh.post_batch_applied(three_pc_batch)
def test_fee_batch_handler_commit_batch(fee_batch_handler, fees_tracker):
utxo_cache = fee_batch_handler.database_manager.get_store(UTXO_CACHE_LABEL)
utxo_cache.set('1', '2')
fee_batch_handler.database_manager.get_state(TOKEN_LEDGER_ID).set('1'.encode(), '2'.encode())
fees_tracker.fees_in_current_batch = 1
fee_batch_handler.post_batch_applied(None, None)
fees_tracker.add_deducted_fees(NYM, 1, 1)
prev_res = [{
TXN_METADATA: {
TXN_METADATA_SEQ_NO: 1
},
TXN_PAYLOAD: {
TXN_PAYLOAD_TYPE: NYM
}
}]
three_pc_batch = ThreePcBatch(0, 0, 0, 3, 1, 'state', 'txn',
['a', 'b', 'c'], ['a'], 0)
fee_batch_handler.commit_batch(three_pc_batch, prev_res)
assert not len(utxo_cache.current_batch_ops)
assert not len(utxo_cache.un_committed)
assert fee_batch_handler.token_ledger.committed_root_hash == fee_batch_handler.token_ledger.uncommitted_root_hash
assert fee_batch_handler.token_state.headHash == fee_batch_handler.token_state.committedHeadHash
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_future_primaries_replicas_increase(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_stewards, tdir, tconf, allPluginsPath):
# Don't delete NodeStates, so we could check them.
global old_commit
old_commit = txnPoolNodeSet[0].write_manager.future_primary_handler.commit_batch
for node in txnPoolNodeSet:
node.write_manager.future_primary_handler.commit_batch = lambda three_pc_batch, prev_handler_result=None: 0
initial_primaries = copy.copy(txnPoolNodeSet[0].primaries)
last_ordered = txnPoolNodeSet[0].master_replica.last_ordered_3pc
starting_view_number = checkViewNoForNodes(txnPoolNodeSet)
# Increase replicas count
add_new_node(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_stewards[0], tdir, tconf, allPluginsPath)
new_view_no = checkViewNoForNodes(txnPoolNodeSet)
assert new_view_no == starting_view_number + 1
# "seq_no + 2" because 1 domain and 1 pool txn.
node = txnPoolNodeSet[0]
with delay_rules(node.nodeIbStasher, cDelay()):
req = sdk_send_random_and_check(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_stewards[0], 1)[0][0]
req = Request(**req)
three_pc_batch = ThreePcBatch(DOMAIN_LEDGER_ID, 0, 0, 1, time.time(),
randomString(),
randomString(),
['a', 'b', 'c'], [req.digest], pp_digest='')
primaries = node.write_manager.future_primary_handler.post_batch_applied(three_pc_batch)
assert len(primaries) == len(initial_primaries) + 1
assert len(primaries) == len(node.primaries)
def test_future_primaries_replicas_decrease(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_wallet_stewards, tdir, tconf, allPluginsPath):
assert len(txnPoolNodeSet) == 7
initial_primaries = copy.copy(txnPoolNodeSet[0].primaries)
last_ordered = txnPoolNodeSet[0].master_replica.last_ordered_3pc
starting_view_number = checkViewNoForNodes(txnPoolNodeSet)
# Decrease replicas count
demote_node(looper, sdk_wallet_stewards[-1], sdk_pool_handle, txnPoolNodeSet[-2])
txnPoolNodeSet.remove(txnPoolNodeSet[-2])
ensureElectionsDone(looper=looper, nodes=txnPoolNodeSet)
new_view_no = checkViewNoForNodes(txnPoolNodeSet)
assert new_view_no == starting_view_number + 1
node = txnPoolNodeSet[0]
with delay_rules(node.nodeIbStasher, cDelay()):
req = sdk_send_random_and_check(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_stewards[0], 1)[0][0]
req = Request(**req)
three_pc_batch = ThreePcBatch(DOMAIN_LEDGER_ID, 0, 0, 1, time.time(),
randomString(),
randomString(),
['a', 'b', 'c'], [req.digest], pp_digest='')
primaries = node.write_manager.future_primary_handler.post_batch_applied(three_pc_batch)
assert len(primaries) + 1 == len(initial_primaries)
assert len(primaries) == len(txnPoolNodeSet[0].primaries)
for node in txnPoolNodeSet:
node.write_manager.future_primary_handler.commit_batch = old_commit
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 get_3PC_batch(root_hash, ledger_id=1):
return ThreePcBatch(ledger_id,
0,
0,
1,
5000,
root_hash,
"", ["Alpha", "Beta"], [],
pp_digest='')
def three_pc_batch():
fp = ThreePcBatch(0,
0,
0,
3,
1,
'state',
'txn', ['a', 'b', 'c'], ['a'],
pp_digest='')
return fp
def three_pc_batch(batch_handler):
# Constant root hash is one which will be formed after applying txn
return ThreePcBatch(LEDGER_ID,
0,
0,
1,
time.time(),
batch_handler.state.headHash,
FIXED_HASH, ['d1', 'd2', 'd3'],
'pp_digest',
primaries=['a', 'b', 'c'])
def _do_apply_batch(self, batch):
reqs = [Request(**req_dict) for req_dict in batch[f.REQUESTS.nm]]
pp_time = batch[f.PP_TIME.nm]
ledger_id = batch[f.LEDGER_ID.nm]
state_root = batch[f.STATE_ROOT.nm]
txn_root = batch[f.TXN_ROOT.nm]
three_pc_batch = ThreePcBatch.from_batch_committed_dict(batch)
self._node.apply_reqs(reqs, three_pc_batch)
self._node.get_executer(ledger_id)(pp_time, reqs, state_root, txn_root)
def _do_apply_batch(self, batch):
reqs = [Request(**req_dict) for req_dict in batch[f.REQUESTS.nm]]
ledger_id = batch[f.LEDGER_ID.nm]
three_pc_batch = ThreePcBatch.from_batch_committed_dict(batch)
self._node.apply_reqs(reqs, three_pc_batch)
# We need hashes in apply and str in commit
three_pc_batch.txn_root = Ledger.hashToStr(three_pc_batch.txn_root)
three_pc_batch.state_root = Ledger.hashToStr(three_pc_batch.state_root)
self._node.get_executer(ledger_id)(three_pc_batch)
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
node_reg = list(self.node.nodeReg.keys())
number_of_inst = getMaxFailures(len(node_reg)) + 1
view_no = self.node.viewNo if three_pc_batch.original_view_no is None else three_pc_batch.original_view_no
validators = TxnPoolManager.calc_node_names_ordered_by_rank(
node_reg, copy.deepcopy(self.node.nodeIds))
three_pc_batch.primaries = self.node.primaries_selector.select_primaries(
view_no=view_no,
instance_count=number_of_inst,
validators=validators)
return three_pc_batch.primaries
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
view_no = self.node.viewNo if three_pc_batch.original_view_no is None else three_pc_batch.original_view_no
primaries = self.get_primaries(view_no)
if primaries is None:
# In case of reordering after view_change
# we can trust for list of primaries from PrePrepare
# because this PrePrepare was validated on all the nodes
primaries = three_pc_batch.primaries
self.set_primaries(view_no, primaries)
three_pc_batch.primaries = primaries
return three_pc_batch.primaries
def add_txns_to_audit(alh, count, ledger_id, txns_per_batch, view_no,
initial_pp_seq_no, pp_time):
db_manager = alh.database_manager
for i in range(count):
add_txns(db_manager, ledger_id, txns_per_batch, pp_time)
three_pc_batch = ThreePcBatch(
ledger_id=ledger_id,
inst_id=0,
view_no=view_no,
pp_seq_no=initial_pp_seq_no + i,
pp_time=pp_time,
valid_txn_count=txns_per_batch,
state_root=db_manager.get_state(ledger_id).headHash,
txn_root=db_manager.get_ledger(ledger_id).uncommitted_root_hash)
alh._add_to_ledger(three_pc_batch)
alh.ledger.commitTxns(count)
def emulate_ordered_processing(self, msg: Ordered):
three_pc_batch = ThreePcBatch.from_ordered(msg)
three_pc_batch.txn_root = Ledger.hashToStr(three_pc_batch.txn_root)
three_pc_batch.state_root = Ledger.hashToStr(three_pc_batch.state_root)
self._write_manager.commit_batch(three_pc_batch)
possible_added = set(three_pc_batch.node_reg) - set(self._previous_node_reg)
possible_removed = set(self._previous_node_reg) - set(three_pc_batch.node_reg)
if possible_added:
for node_name in list(possible_added):
self._internal_bus.send(NeedAddNode(node_name, self.name))
if possible_removed:
for node_name in list(possible_removed):
self._internal_bus.send(NeedRemoveNode(node_name, self.name))
if possible_added or possible_removed:
self._previous_node_reg = three_pc_batch.node_reg
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
# Observer case:
if not self.uncommitted_node_reg and three_pc_batch.node_reg:
self.uncommitted_node_reg = list(three_pc_batch.node_reg)
view_no = three_pc_batch.view_no if three_pc_batch.original_view_no is None else three_pc_batch.original_view_no
self._uncommitted.append(
UncommittedNodeReg(list(self.uncommitted_node_reg), view_no))
three_pc_batch.node_reg = list(self.uncommitted_node_reg)
logger.debug("Applied uncommitted node registry: {}".format(
self.uncommitted_node_reg))
logger.debug("Current node registry for previous views: {}".format(
sorted(self.node_reg_at_beginning_of_view.items())))
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
node_txn_count = 0
last_state = None
if len(self.node_states) == 0:
last_state = self.create_node_state_from_current_node()
else:
last_state = copy.deepcopy(self.node_states[-1])
for digest in three_pc_batch.valid_digests:
if digest not in self.node.requests:
raise LogicError('Request is absent when it is applying')
request = self.node.requests[digest].request
if request.operation.get(TXN_TYPE) == NODE \
and request.operation.get(DATA).get(SERVICES) is not None:
node_txn_count += 1
node_nym = request.operation.get(TARGET_NYM)
node_name = request.operation.get(DATA).get(ALIAS)
curName = last_state.node_ids.get(node_nym)
if curName is None:
last_state.node_ids[node_nym] = node_name
elif curName != node_name:
raise LogicError("Alias inconsistency")
serv = request.operation.get(DATA).get(SERVICES)
if VALIDATOR in serv and node_name not in last_state.node_reg:
last_state.node_reg.append(node_name)
elif serv == [] and node_name in last_state.node_reg:
last_state.node_reg.remove(node_name)
count = self.get_required_number_of_instances(
len(last_state.node_reg))
if last_state.number_of_inst != count:
last_state.number_of_inst = count
new_validators = TxnPoolManager.calc_node_names_ordered_by_rank(
last_state.node_reg, last_state.node_ids)
last_state.primaries = self.node.primaries_selector.select_primaries(
view_no=self.node.viewNo,
instance_count=last_state.number_of_inst,
validators=new_validators)
# We will save node state at every pool batch, so we could revert it correctly
self.node_states.append(last_state)
three_pc_batch.primaries = last_state.primaries
return last_state.primaries
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
# Observer case:
if not self.uncommitted_node_reg and three_pc_batch.node_reg:
self.uncommitted_node_reg = list(three_pc_batch.node_reg)
view_no = three_pc_batch.view_no if three_pc_batch.original_view_no is None else three_pc_batch.original_view_no
self._uncommitted.append(
UncommittedNodeReg(list(self.uncommitted_node_reg), view_no))
if view_no > self._uncommitted_view_no:
self.node_reg_at_beginning_of_view[view_no] = list(
self.uncommitted_node_reg)
self._uncommitted_view_no = three_pc_batch.view_no
three_pc_batch.node_reg = self.uncommitted_node_reg
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 do_apply_audit_txn(alh,
txns_count,
ledger_id,
view_no,
pp_sq_no,
txn_time,
has_audit_txn=True):
db_manager = alh.database_manager
add_txns(db_manager, ledger_id, txns_count, txn_time)
three_pc_batch = ThreePcBatch(
ledger_id=ledger_id,
inst_id=0,
view_no=view_no,
pp_seq_no=pp_sq_no,
pp_time=txn_time,
valid_txn_count=txns_count,
state_root=db_manager.get_state(ledger_id).headHash,
txn_root=db_manager.get_ledger(ledger_id).uncommitted_root_hash,
has_audit_txn=has_audit_txn)
alh.post_batch_applied(three_pc_batch)
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
def post_batch_applied(self,
three_pc_batch: ThreePcBatch,
prev_handler_result=None):
view_no = three_pc_batch.original_view_no if three_pc_batch.original_view_no is not None else three_pc_batch.view_no
three_pc_batch.primaries = self.primaries_selector.select_primaries(
view_no)
