def add_new_nym(looper, sdk_pool_handle, creators_wallets, alias=None, role=None, seed=None, dest=None, verkey=None, skipverkey=False, no_wait=False): seed = seed or randomString(32) alias = alias or randomString(5) wh, _ = creators_wallets[0] # filling nym request and getting steward did # if role == None, we are adding client nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(creators_wallets[0], seed, alias, role, dest, verkey, skipverkey)) # sending request using 'sdk_' functions signed_reqs = sdk_multi_sign_request_objects( looper, creators_wallets, [sdk_json_to_request_object(json.loads(nym_request))]) request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0] if no_wait: return request_couple # waitng for replies sdk_get_and_check_replies(looper, [request_couple])
def testLoggingTxnStateForInvalidRequest(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, logsearch): logsPropagate, _ = logsearch(files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsReject, _ = logsearch( files=['ordering_service.py'], funcs=['_consume_req_queue_for_pre_prepare'], msgs=['encountered exception.*while processing.*will reject']) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, "name", STEWARD_STRING)) request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_client, sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'Only Steward is allowed to do these transactions' in e._excinfo[ 1].args[0] request = request_couple[0] req_id = str(request[f.REQ_ID.nm]) digest = get_key_from_req(request) assert any(digest in record.getMessage() for record in logsPropagate) assert any(req_id in record.getMessage() for record in logsReject)
def testLoggingTxnStateForInvalidRequest(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, logsearch): logsPropagate, _ = logsearch(levels=['INFO'], files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsReject, _ = logsearch( levels=['WARNING'], files=['replica.py'], funcs=['processReqDuringBatch'], msgs=['encountered exception.*while processing.*will reject']) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, "name", STEWARD_STRING)) request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_client, sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'Only Steward is allowed to do these transactions' in e._excinfo[ 1].args[0] reqId = str(json.loads(nym_request)['reqId']) assert any(reqId in record.getMessage() for record in logsPropagate) assert any(reqId in record.getMessage() for record in logsReject)
def testLoggingTxnStateForInvalidRequest( looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_client, logsearch): logsPropagate, _ = logsearch(files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsReject, _ = logsearch(files=['replica.py'], funcs=['consume_req_queue_for_pre_prepare'], msgs=['encountered exception.*while processing.*will reject']) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, "name", STEWARD_STRING)) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, nym_request) with pytest.raises(RequestRejectedException) as e: sdk_get_and_check_replies(looper, [request_couple]) assert 'Only Steward is allowed to do these transactions' in e._excinfo[1].args[0] request = json.loads(nym_request) req_id = str(request[f.REQ_ID.nm]) digest = get_key_from_req(request) assert any(digest in record.getMessage() for record in logsPropagate) assert any(req_id in record.getMessage() for record in logsReject)
def test_get_txn_response_as_expected(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward): seed = randomString(32) wh, _ = sdk_wallet_steward # filling nym request and getting steward did # if role == None, we are adding client nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, None, None)) # sending request using 'sdk_' functions request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_steward, sdk_pool_handle, nym_request) result1 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] seqNo = get_seq_no(result1) _, steward_did = sdk_wallet_steward request = sdk_build_get_txn_request(looper, steward_did, seqNo) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) result2 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] assert result1['reqSignature'] == result2['data']['reqSignature'] assert result1['txn'] == result2['data']['txn'] assert result1['txnMetadata'] == result2['data']['txnMetadata'] assert result1['rootHash'] == result2['data']['rootHash'] assert result1['ver'] == result2['data']['ver'] assert result1['auditPath'] == result2['data']['auditPath']
def test_get_txn_response_as_expected(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward): seed = randomString(32) wh, _ = sdk_wallet_steward # filling nym request and getting steward did # if role == None, we are adding client nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, None, None)) # sending request using 'sdk_' functions request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_steward, sdk_pool_handle, nym_request) result1 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] seqNo = get_seq_no(result1) _, steward_did = sdk_wallet_steward request = sdk_build_get_txn_request(looper, steward_did, seqNo) request_couple = \ sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, request) result2 = sdk_get_and_check_replies(looper, [request_couple])[0][1]['result'] assert result1 == result2['data']
def two_requests(looper, helpers, nodeSetWithIntegratedTokenPlugin, sdk_pool_handle, fees_set, address_main, mint_tokens, sdk_wallet_steward): amount = get_amount_from_token_txn(mint_tokens) init_seq_no = 1 seed = randomString(32) alias = randomString(5) wh, _ = sdk_wallet_steward nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, alias, None)) nym_request = \ sdk_sign_request_objects(looper, sdk_wallet_steward, [sdk_json_to_request_object(json.loads(nym_request))])[0] req_obj = sdk_json_to_request_object(json.loads(nym_request)) helpers.request.nym = lambda: copy.deepcopy(req_obj) req1, req2 = nyms_with_fees(2, helpers, fees_set, address_main, amount, init_seq_no=init_seq_no) assert req1.payload_digest == req2.payload_digest assert req1.digest != req2.digest return req1, req2
def set_verkey(looper, sdk_pool_handle, sdk_wallet_sender, dest, verkey): wh, _ = sdk_wallet_sender nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_sender, None, None, TRUST_ANCHOR_STRING, dest, verkey, False if verkey else True)) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_sender, sdk_pool_handle, nym_request) sdk_get_and_check_replies(looper, [request_couple]) return wh, new_did
def set_verkey(looper, sdk_pool_handle, sdk_wallet_sender, dest, verkey): wh, _ = sdk_wallet_sender nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_sender, None, None, TRUST_ANCHOR_STRING, dest, verkey, False if verkey else True)) request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_sender, sdk_pool_handle, nym_request) sdk_get_and_check_replies(looper, [request_couple]) return wh, new_did
def nym_request(looper, sdk_wallet_trustee): seed = randomString(32) alias = randomString(5) dest = None role = None verkey = None nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_trustee, seed, alias, role, dest, verkey, True)) return json.loads(nym_request)
def _build_nym(self, creator_wallet, role_string, did, verkey=None, skipverkey=True): seed = randomString(32) alias = randomString(5) nym_request, new_did = self.looper.loop.run_until_complete( prepare_nym_request(creator_wallet, seed, alias, role_string, dest=did, verkey=verkey, skipverkey=skipverkey)) return sdk_json_to_request_object(json.loads(nym_request))
def sdk_add_new_nym_without_waiting(looper, sdk_pool_handle, creators_wallet, alias=None, role=None, seed=None, dest=None, verkey=None, skipverkey=False): seed = seed or randomString(32) alias = alias or randomString(5) wh, _ = creators_wallet nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(creators_wallet, seed, alias, role, dest, verkey, skipverkey)) sdk_sign_and_send_prepared_request(looper, creators_wallet, sdk_pool_handle, nym_request)
def test_requests_collection_debugging(looper, nodeSet, sdk_wallet_trustee): primary = nodeSet[0] seed = randomString(32) alias = randomString(5) wh, _ = sdk_wallet_trustee nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_trustee, seed, alias, STEWARD_STRING)) nym_request = json.loads(nym_request) a = sys.getsizeof(primary.requests) mas = [] for _ in range(50000): req = sdk_json_to_request_object(nym_request) req.reqId = randomString(32) mas.append(req) primary.requests.add_propagate(req, 'asd') primary.requests.mark_as_forwarded(req, 2) primary.requests.set_finalised(req) b = sys.getsizeof(primary.requests) lb = len(primary.requests) for req in mas: primary.requests.mark_as_executed(req) primary.requests.free(req.key) primary.requests.free(req.key) c = sys.getsizeof(primary.requests) lc = len(primary.requests) for _ in range(100000): req = sdk_json_to_request_object(nym_request) req.reqId = randomString(32) mas.append(req) primary.requests.add_propagate(req, 'asd') primary.requests.mark_as_forwarded(req, 2) primary.requests.set_finalised(req) d = sys.getsizeof(primary.requests) ld = len(primary.requests) print(a) print(b, lb) print(c, lc) print(d, ld)
def test_forced_request_validation(looper, txnPoolNodeSet, sdk_wallet_client, sdk_pool_handle, sdk_wallet_steward): nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, randomString(32), None, None)) request_json = json.loads(nym_request) request_json['operation'][FORCE] = True node_request = json.dumps(request_json) request_couple = sdk_sign_and_send_prepared_request( looper, sdk_wallet_client, sdk_pool_handle, node_request) with pytest.raises(RequestNackedException): sdk_get_and_check_replies(looper, [request_couple]) sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward)
def _build_nym(self, creator_wallet, role_string, did, verkey=None, skipverkey=True): seed = randomString(32) alias = randomString(5) nym_request, _ = self.looper.loop.run_until_complete( prepare_nym_request(creator_wallet, seed, alias, role_string, dest=did, verkey=verkey, skipverkey=skipverkey)) return nym_request
def test_txn_with_different_signature_and_idr(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_trustee, sdk_wallet_client): # filling nym request and getting steward did nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_trustee, randomString(32), 'newSteward1', STEWARD_STRING)) # sending request using 'sdk_' functions signed_reqs = sdk_multi_sign_request_objects( looper, [sdk_wallet_client], [sdk_json_to_request_object(json.loads(nym_request))]) request_couple = sdk_send_signed_requests(sdk_pool_handle, signed_reqs)[0] with pytest.raises(RequestNackedException, match="The identifier is not contained in signatures"): # waiting for replies sdk_get_and_check_replies(looper, [request_couple])
def testOnlyAStewardCanAddAnotherSteward(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, sdk_wallet_client): sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, alias='testSteward' + randomString(3), role=STEWARD_STRING) seed = randomString(32) wh, _ = sdk_wallet_client nym_request, steward_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_client, seed, 'testSteward2', 'STEWARD')) request_couple = sdk_sign_and_send_prepared_request(looper, sdk_wallet_client, sdk_pool_handle, nym_request) total_timeout = sdk_eval_timeout(1, len(txnPoolNodeSet)) request_couple = sdk_get_replies(looper, [request_couple], total_timeout)[0] with pytest.raises(RequestRejectedException) as e: sdk_check_reply(request_couple) assert 'Only Steward is allowed to do these transactions' in e._excinfo[1].args[0]
def testLoggingTxnStateWhenCommitFails( looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, logsearch): logsPropagate, _ = logsearch(files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsOrdered, _ = logsearch(files=['replica.py'], funcs=['order_3pc_key'], msgs=['ordered batch request']) logsCommitFail, _ = logsearch(files=['node.py'], funcs=['executeBatch'], msgs=['commit failed for batch request']) seed = randomString(32) wh, _ = sdk_wallet_steward nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, "name", None)) sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, nym_request) class SomeError(Exception): pass def commitPatched(node, commitOrig, *args, **kwargs): req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = commitOrig raise SomeError(ERORR_MSG) excCounter = 0 def executeBatchPatched(node, executeBatchOrig, *args, **kwargs): nonlocal excCounter try: executeBatchOrig(*args, **kwargs) except SomeError: excCounter += 1 node.executeBatch = executeBatchOrig pass def checkSufficientExceptionsHappend(): assert excCounter == len(txnPoolNodeSet) return for node in txnPoolNodeSet: req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = functools.partial( commitPatched, node, req_handler.commit ) node.executeBatch = functools.partial( executeBatchPatched, node, node.executeBatch ) timeout = waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)) looper.run( eventually(checkSufficientExceptionsHappend, retryWait=1, timeout=timeout)) request = json.loads(nym_request) digest = get_key_from_req(request) assert any(digest in record.getMessage() for record in logsPropagate) assert any(digest in record.getMessage() for record in logsOrdered) assert any(digest in record.getMessage() for record in logsCommitFail) assert any(ERORR_MSG in record.getMessage() for record in logsCommitFail)
def test_successive_batch_do_no_change_state(looper, tconf, nodeSet, sdk_pool_handle, sdk_wallet_trustee, monkeypatch): """ Send 2 NYM txns in different batches such that the second batch does not change state so that state root remains same, but keep the identifier and reqId different. Make sure the first request is not ordered by the primary before PRE-PREPARE for the second is sent. Also check reject and commit :return: """ # Disable view change during this test for n in nodeSet: n.nodeIbStasher.delay(icDelay()) # Delay only first PRE-PREPARE delay_cm_duration = 10 def delay_commits(wrappedMsg): msg, sender = wrappedMsg if isinstance(msg, Commit) and msg.instId == 0: return delay_cm_duration def check_verkey(i, vk): for node in nodeSet: data = node.idrCache.getNym(i, isCommitted=True) assert data[VERKEY] == vk def check_uncommitted(count): for node in nodeSet: assert len(node.idrCache.un_committed) == count for node in nodeSet: for rpl in node.replicas: monkeypatch.setattr(rpl, '_request_missing_three_phase_messages', lambda *x, **y: None) wh, did = sdk_wallet_trustee seed = randomString(32) (new_did, verkey) = looper.loop.run_until_complete( create_and_store_my_did(wh, json.dumps({'seed': seed}))) sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee, dest=new_did, verkey=verkey) for node in nodeSet: node.nodeIbStasher.delay(delay_commits) # Setting the same verkey thrice but in different batches with different # request ids for _ in range(3): verkey = sdk_rotate_verkey(looper, sdk_pool_handle, wh, new_did, new_did, seed) logger.debug('{} rotates his key to {}'.format(new_did, verkey)) # Number of uncommitted entries is 0 looper.run(eventually(check_uncommitted, 0)) check_verkey(new_did, verkey) # Setting the verkey to `x`, then `y` and then back to `x` but in different # batches with different request ids. The idea is to change # state root to `t` then `t'` and then back to `t` and observe that no # errors are encountered seed = randomString(32) (new_client_did, verkey) = looper.loop.run_until_complete( create_and_store_my_did(wh, json.dumps({'seed': seed}))) sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_trustee, dest=new_client_did, verkey=verkey) x_seed = randomString(32) verkey = sdk_rotate_verkey(looper, sdk_pool_handle, wh, new_client_did, new_client_did, x_seed) logger.debug('{} rotates his key to {}'.format(new_client_did, verkey)) y_seed = randomString(32) sdk_rotate_verkey(looper, sdk_pool_handle, wh, new_client_did, new_client_did, y_seed) logger.debug('{} rotates his key to {}'.format(new_client_did, verkey)) sdk_rotate_verkey(looper, sdk_pool_handle, wh, new_client_did, new_client_did, x_seed) logger.debug('{} rotates his key to {}'.format(new_client_did, verkey)) # Number of uncommitted entries is 0 looper.run(eventually(check_uncommitted, 0)) check_verkey(new_client_did, verkey) monkeypatch.undo() # Delay COMMITs so that IdrCache can be checked for correct # number of entries uncommitteds = {} methods = {} for node in nodeSet: cache = node.idrCache # type: IdrCache uncommitteds[cache._name] = [] # Since the post batch creation handler is registered (added to a list), # find it and patch it dh = node.get_req_handler(DOMAIN_LEDGER_ID) for i, handler in enumerate(dh.post_batch_creation_handlers): # Find the cache's post create handler, not hardcoding names of # class or functions as they can change with refactoring. if handler.__func__.__qualname__ == '{}.{}'.format( cache.__class__.__name__, cache.currentBatchCreated.__name__): cre = dh.post_batch_creation_handlers[i] break com = cache.onBatchCommitted methods[cache._name] = (cre, com) # Patch methods to record and check roots after commit def patched_cre(self, stateRoot): uncommitteds[self._name].append(stateRoot) return methods[self._name][0](stateRoot) def patched_com(self, stateRoot): assert uncommitteds[self._name][0] == stateRoot rv = methods[self._name][1](stateRoot) uncommitteds[self._name] = uncommitteds[self._name][1:] return rv dh.post_batch_creation_handlers[i] = types.MethodType( patched_cre, cache) cache.onBatchCommitted = types.MethodType(patched_com, cache) # Set verkey of multiple identities more = 5 keys = {} reqs = [] for _ in range(more): seed = randomString(32) nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_trustee, seed, None, None)) keys[new_did] = json.loads(nym_request)['operation']['verkey'] reqs.append( sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, nym_request)) looper.runFor(.01) # Correct number of uncommitted entries looper.run(eventually(check_uncommitted, more, retryWait=1)) sdk_get_and_check_replies(looper, reqs) # Number of uncommitted entries is 0 looper.run(eventually(check_uncommitted, 0)) # The verkeys are correct for i, v in keys.items(): check_verkey(i, v) waitNodeDataEquality(looper, nodeSet[0], *nodeSet[1:]) for _ in range(3): seed = randomString(32) nym_request, new_did = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_trustee, seed, None, None)) reqs.append( sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, nym_request)) looper.runFor(.01) # Correct number of uncommitted entries looper.run(eventually(check_uncommitted, 3, retryWait=1)) # Check batch reject for node in nodeSet: cache = node.idrCache initial = cache.un_committed cache.batchRejected() # After reject, last entry is removed assert cache.un_committed == initial[:-1] root = cache.un_committed[0][0] cache.onBatchCommitted(root) # Calling commit with same root results in Assertion error with pytest.raises(AssertionError): cache.onBatchCommitted(root)
def testLoggingTxnStateWhenCommitFails(looper, txnPoolNodeSet, sdk_pool_handle, sdk_wallet_steward, logsearch): logsPropagate, _ = logsearch(levels=['INFO'], files=['propagator.py'], funcs=['propagate'], msgs=['propagating.*request.*from client']) logsOrdered, _ = logsearch(levels=['INFO'], files=['replica.py'], funcs=['order_3pc_key'], msgs=['ordered batch request']) logsCommitFail, _ = logsearch(levels=['WARNING'], files=['node.py'], funcs=['executeBatch'], msgs=['commit failed for batch request']) seed = randomString(32) wh, _ = sdk_wallet_steward nym_request, _ = looper.loop.run_until_complete( prepare_nym_request(sdk_wallet_steward, seed, "name", None)) sdk_sign_and_send_prepared_request(looper, sdk_wallet_steward, sdk_pool_handle, nym_request) class SomeError(Exception): pass def commitPatched(node, commitOrig, *args, **kwargs): req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = commitOrig raise SomeError(ERORR_MSG) excCounter = 0 def executeBatchPatched(node, executeBatchOrig, *args, **kwargs): nonlocal excCounter try: executeBatchOrig(*args, **kwargs) except SomeError: excCounter += 1 node.executeBatch = executeBatchOrig pass def checkSufficientExceptionsHappend(): assert excCounter == len(txnPoolNodeSet) return for node in txnPoolNodeSet: req_handler = node.get_req_handler(ledger_id=DOMAIN_LEDGER_ID) req_handler.commit = functools.partial(commitPatched, node, req_handler.commit) node.executeBatch = functools.partial(executeBatchPatched, node, node.executeBatch) timeout = waits.expectedTransactionExecutionTime(len(txnPoolNodeSet)) looper.run( eventually(checkSufficientExceptionsHappend, retryWait=1, timeout=timeout)) reqId = str(json.loads(nym_request)['reqId']) assert any(reqId in record.getMessage() for record in logsPropagate) assert any(reqId in record.getMessage() for record in logsOrdered) assert any(reqId in record.getMessage() for record in logsCommitFail) assert any(ERORR_MSG in record.getMessage() for record in logsCommitFail)
def build_nym_request(looper, sdk_wallet): return looper.loop.run_until_complete( prepare_nym_request(sdk_wallet, named_seed=randomString(32), alias=randomString(5), role=None))[0]