def test_constraint_serialization(constraints):
constraint_serializer = ConstraintsSerializer(domain_state_serializer)
for constraint in constraints:
serialized = constraint_serializer.serialize(constraint)
deserialized = constraint_serializer.deserialize(serialized)
assert constraint == deserialized
assert constraint_serializer.serialize(constraint) == \
constraint_serializer.serialize(deserialized)
def _init_write_request_validator(self):
constraint_serializer = ConstraintsSerializer(domain_state_serializer)
config_state = self.states[CONFIG_LEDGER_ID]
self.write_req_validator = WriteRequestValidator(config=self.config,
auth_map=auth_map,
cache=self.getIdrCache(),
config_state=config_state,
state_serializer=constraint_serializer,
anyone_can_write_map=anyone_can_write_map,)
def _init_write_request_validator(self):
constraint_serializer = ConstraintsSerializer(domain_state_serializer)
config_state = self.node.states[CONFIG_LEDGER_ID]
self.node.write_req_validator = WriteRequestValidator(config=self.node.config,
auth_map=auth_map,
cache=self.node.idrCache,
config_state=config_state,
state_serializer=constraint_serializer,
metrics=self.node.metrics)
def __init__(self, ledger, state, idrCache: IdrCache, upgrader: Upgrader,
poolManager, poolCfg: PoolConfig, write_req_validator):
super().__init__(ledger, state)
self.idrCache = idrCache
self.upgrader = upgrader
self.poolManager = poolManager
self.poolCfg = poolCfg
self.write_req_validator = write_req_validator
self.constraint_serializer = ConstraintsSerializer(
domain_state_serializer)
def __init__(self, ledger, state, domain_state, idrCache: IdrCache,
upgrader: Upgrader, poolManager, poolCfg: PoolConfig,
write_req_validator, bls_store=None, ts_store: Optional[StateTsDbStorage] = None):
super().__init__(ledger, state, domain_state, bls_store, ts_store)
self.idrCache = idrCache
self.upgrader = upgrader
self.poolManager = poolManager
self.poolCfg = poolCfg
self.write_req_validator = write_req_validator
self.constraint_serializer = ConstraintsSerializer(config_state_serializer)
self._add_query_handler(GET_AUTH_RULE, self.handle_get_auth_rule)
def test_catching_up_auth_rule_txn(looper, txnPoolNodeSet, sdk_wallet_trustee,
sdk_wallet_steward, sdk_pool_handle):
delayed_node = txnPoolNodeSet[-1]
wh, _ = sdk_wallet_trustee
new_steward_did, new_steward_verkey = create_verkey_did(looper, wh)
changed_constraint = AuthConstraint(role=STEWARD, sig_count=1)
action = AuthActionAdd(txn_type=NYM, field=ROLE, value=STEWARD)
with pytest.raises(RequestRejectedException,
match="Not enough TRUSTEE signatures"):
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_steward,
'newSteward2',
STEWARD_STRING,
dest=new_steward_did,
verkey=new_steward_verkey)
with delay_rules_without_processing(delayed_node.nodeIbStasher, cDelay(),
pDelay(), ppDelay()):
sdk_send_and_check_auth_rule_request(
looper,
sdk_pool_handle,
sdk_wallet_trustee,
auth_action=ADD_PREFIX,
auth_type=action.txn_type,
field=action.field,
new_value=action.value,
old_value=None,
constraint=changed_constraint.as_dict)
sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee,
'newSteward2')
delayed_node.start_catchup()
looper.run(
eventually(
lambda: assertExp(delayed_node.mode == Mode.participating)))
sdk_add_new_nym(looper,
sdk_pool_handle,
sdk_wallet_steward,
'newSteward3',
STEWARD_STRING,
dest=new_steward_did,
verkey=new_steward_verkey)
ensure_all_nodes_have_same_data(looper, txnPoolNodeSet)
config_state = delayed_node.states[CONFIG_LEDGER_ID]
from_state = config_state.get(config.make_state_path_for_auth_rule(
action.get_action_id()),
isCommitted=True)
assert changed_constraint == ConstraintsSerializer(
config_state_serializer).deserialize(from_state)
def request_handler(bls_store):
state = PruningState(KeyValueStorageInMemory())
config_state = PruningState(KeyValueStorageInMemory())
state_serializer = ConstraintsSerializer(domain_state_serializer)
cache = IdrCache('Cache', KeyValueStorageInMemory())
attr_store = AttributeStore(KeyValueStorageInMemory())
write_req_validator = WriteRequestValidator(
config=FakeSomething(authPolicy=CONFIG_LEDGER_AUTH_POLICY),
auth_map=auth_map,
cache=cache,
config_state=config_state,
state_serializer=state_serializer)
return DomainReqHandler(ledger=None,
state=state,
config=None,
requestProcessor=None,
idrCache=cache,
attributeStore=attr_store,
bls_store=bls_store,
write_req_validator=write_req_validator,
ts_store=None)
def __init__(self, database_manager: DatabaseManager,
write_req_validator: WriteRequestValidator, txn_type):
super().__init__(database_manager, txn_type, CONFIG_LEDGER_ID)
self.write_req_validator = write_req_validator
self.constraint_serializer = ConstraintsSerializer(domain_state_serializer)
def constraint_serializer():
return ConstraintsSerializer(domain_state_serializer)