def test_pool_restarts_one_by_one_with_restart_now(sdk_pool_handle,
sdk_wallet_trustee, looper,
tconf, txnPoolNodeSet):
server, indicator = looper.loop.run_until_complete(
_createServer(host=tconf.controlServiceHost,
port=tconf.controlServicePort))
unow = datetime.utcnow().replace(tzinfo=dateutil.tz.tzutc())
first_start = str(datetime.isoformat(unow + timedelta(seconds=1000)))
op = {TXN_TYPE: POOL_RESTART, ACTION: START, DATETIME: first_start}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
sdk_get_reply(looper, req, 100)
op[DATETIME] = "0"
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
sdk_get_reply(looper, req, 100)
restart_log = []
for a in txnPoolNodeSet[0].restarter._actionLog:
restart_log.append(a)
restart_log.reverse()
_check_restart_log(restart_log[1], RestartLog.SCHEDULED, first_start)
_check_restart_log(restart_log[0], RestartLog.CANCELLED)
_stopServer(server)
def do_view_change_with_unaligned_prepare_certificates(
slow_nodes, nodes, looper, sdk_pool_handle, sdk_wallet_client):
"""
Perform view change with some nodes reaching lower last prepared certificate than others.
With current implementation of view change this can result with view change taking a lot of time.
"""
fast_nodes = [n for n in nodes if n not in slow_nodes]
all_stashers = [n.nodeIbStasher for n in nodes]
slow_stashers = [n.nodeIbStasher for n in slow_nodes]
# Delay some PREPAREs and all COMMITs
with delay_rules(slow_stashers, pDelay()):
with delay_rules(all_stashers, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
# Wait until this request is prepared on fast nodes
looper.run(eventually(check_last_prepared_certificate, fast_nodes, (0, 1)))
# Make sure its not prepared on slow nodes
looper.run(eventually(check_last_prepared_certificate, slow_nodes, None))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Now commits are processed
# Wait until view change is complete
looper.run(eventually(check_view_change_done, nodes, 1, timeout=60))
# Finish request gracefully
sdk_get_reply(looper, request)
def test_claim_def_reply_is_valid(looper, sdk_pool_handle, sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
schema_json, _ = sdk_write_schema(looper, sdk_pool_handle,
sdk_wallet_steward)
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(
build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
_, schema_json = looper.loop.run_until_complete(
parse_get_schema_response(json.dumps(reply)))
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag", "CL",
json.dumps({"support_revocation": True})))
request = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_claim_def_txn(reply['result']['txn'])
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
stewardWallet, steward1, sdk_wallet_steward,
sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {TXN_TYPE: GET_BAL, DATA: {'id': '123'}}
# Valid field value results in successful processing
req_obj = sdk_gen_request(
op,
identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
req = Request(operation=op,
reqId=Request.gen_req_id(),
protocolVersion=CURRENT_PROTOCOL_VERSION,
identifier=stewardWallet.defaultId,
fix_length_dummy=randomString(dummy_field_length + 1))
steward1.submitReqs(req)
for node in txn_pool_node_set_post_creation:
looper.run(
eventually(checkReqNackWithReason,
steward1,
'should have length',
node.clientstack.name,
retryWait=1))
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
sdk_wallet_steward, sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {TXN_TYPE: GET_BAL, DATA: {'id': '123'}}
# Valid field value results in successful processing
req_obj = sdk_gen_request(
op,
identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_steward, req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
_, did = sdk_wallet_steward
req = sdk_gen_request(op,
identifier=did,
fix_length_dummy=randomString(dummy_field_length +
1))
reqs = sdk_sign_request_objects(looper, sdk_wallet_steward, [req])
reqs = sdk_send_signed_requests(sdk_pool_handle, reqs)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, reqs)
assert 'should have length' in e._excinfo[1].args[0]
def test_pool_restart_cancel(sdk_pool_handle, sdk_wallet_trustee, looper,
tconf, txnPoolNodeSet):
loop = asyncio.get_event_loop()
server, indicator = loop.run_until_complete(
_createServer(host=tconf.controlServiceHost,
port=tconf.controlServicePort))
unow = datetime.utcnow().replace(tzinfo=dateutil.tz.tzutc())
start_at = unow + timedelta(seconds=1000)
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
DATETIME: str(datetime.isoformat(start_at))
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
sdk_get_reply(looper, req, 100)
for node in txnPoolNodeSet:
assert node.restarter.lastActionEventInfo[0] == RestartLog.SCHEDULED
cancel_at = start_at + timedelta(seconds=1000)
op = {TXN_TYPE: POOL_RESTART, ACTION: CANCEL, DATETIME: ""}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet_trustee, req_obj)
req_json, resp = sdk_get_reply(looper, req, 100)
for node in txnPoolNodeSet:
assert node.restarter.lastActionEventInfo[0] == RestartLog.CANCELLED
_stopServer(server)
_comparison_reply(resp, req_obj)
def do_view_change_with_unaligned_prepare_certificates(
slow_nodes, nodes, looper, sdk_pool_handle, sdk_wallet_client):
"""
Perform view change with some nodes reaching lower last prepared certificate than others.
With current implementation of view change this can result with view change taking a lot of time.
"""
fast_nodes = [n for n in nodes if n not in slow_nodes]
all_stashers = [n.nodeIbStasher for n in nodes]
slow_stashers = [n.nodeIbStasher for n in slow_nodes]
# Delay some PREPAREs and all COMMITs
with delay_rules(slow_stashers, pDelay()):
with delay_rules(all_stashers, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
# Wait until this request is prepared on fast nodes
looper.run(eventually(check_last_prepared_certificate, fast_nodes, (0, 1)))
# Make sure its not prepared on slow nodes
looper.run(eventually(check_last_prepared_certificate, slow_nodes, None))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Now commits are processed
# Wait until view change is complete
looper.run(eventually(check_view_change_done, nodes, 1, timeout=60))
# Finish request gracefully
sdk_get_reply(looper, request)
def test_plugin_client_req_fields(txn_pool_node_set_post_creation, looper,
sdk_wallet_steward, sdk_pool_handle):
"""
Test that plugin's addition of request fields and their validation is
successful
"""
op = {
TXN_TYPE: GET_BAL,
DATA: {'id': '123'}
}
# Valid field value results in successful processing
req_obj = sdk_gen_request(op, identifier=sdk_wallet_steward[1],
fix_length_dummy=randomString(dummy_field_length))
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, sdk_wallet_steward,
req_obj)
sdk_get_reply(looper, req)
# Invalid field value results in proper failure
_, did = sdk_wallet_steward
req = sdk_gen_request(op, identifier=did, fix_length_dummy=randomString(dummy_field_length + 1))
reqs = sdk_sign_request_objects(looper, sdk_wallet_steward, [req])
reqs = sdk_send_signed_requests(sdk_pool_handle, reqs)
with pytest.raises(RequestNackedException) as e:
sdk_get_and_check_replies(looper, reqs)
assert 'should have length' in e._excinfo[1].args[0]
def do_view_change_with_propagate_primary_on_one_delayed_node(
slow_node, nodes, looper, sdk_pool_handle, sdk_wallet_client):
slow_stasher = slow_node.nodeIbStasher
fast_nodes = [n for n in nodes if n != slow_node]
stashers = [n.nodeIbStasher for n in nodes]
# Get last prepared certificate in pool
lpc = last_prepared_certificate(nodes)
# Get pool current view no
view_no = lpc[0]
with delay_rules(slow_stasher, icDelay()):
with delay_rules(slow_stasher, vcd_delay()):
with delay_rules(stashers, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
# Wait until this request is prepared on N-f nodes
looper.run(eventually(check_last_prepared_certificate_on_quorum, nodes, (lpc[0], lpc[1] + 1)))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Wait until view change is completed on all nodes except slow one
waitForViewChange(looper,
fast_nodes,
expectedViewNo=view_no + 1,
customTimeout=waits.expectedPoolViewChangeStartedTimeout(len(nodes)))
wait_for_elections_done_on_given_nodes(looper,
fast_nodes,
getRequiredInstances(len(nodes)),
timeout=waits.expectedPoolElectionTimeout(len(nodes)))
# Now all the nodes receive Commits
# The slow node will accept Commits and order the 3PC-batch in the old view
looper.runFor(waits.expectedOrderingTime(getNoInstances(len(nodes))))
# Now slow node receives ViewChangeDones
waitForViewChange(looper,
[slow_node],
expectedViewNo=view_no + 1,
customTimeout=waits.expectedPoolViewChangeStartedTimeout(len(nodes)))
wait_for_elections_done_on_given_nodes(looper,
[slow_node],
getRequiredInstances(len(nodes)),
timeout=waits.expectedPoolElectionTimeout(len(nodes)))
# Now slow node receives InstanceChanges but discards them because already
# started propagate primary to the same view.
# Finish request gracefully
sdk_get_reply(looper, request)
def do_view_change_with_propagate_primary_on_one_delayed_node(
slow_node, nodes, looper, sdk_pool_handle, sdk_wallet_client):
slow_stasher = slow_node.nodeIbStasher
fast_nodes = [n for n in nodes if n != slow_node]
stashers = [n.nodeIbStasher for n in nodes]
# Get last prepared certificate in pool
lpc = last_prepared_certificate(nodes)
# Get pool current view no
view_no = lpc[0]
with delay_rules(slow_stasher, icDelay()):
with delay_rules(slow_stasher, vcd_delay()):
with delay_rules(stashers, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
# Wait until this request is prepared on N-f nodes
looper.run(eventually(check_last_prepared_certificate_on_quorum, nodes, (lpc[0], lpc[1] + 1)))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Wait until view change is completed on all nodes except slow one
waitForViewChange(looper,
fast_nodes,
expectedViewNo=view_no + 1,
customTimeout=waits.expectedPoolViewChangeStartedTimeout(len(nodes)))
wait_for_elections_done_on_given_nodes(looper,
fast_nodes,
getRequiredInstances(len(nodes)),
timeout=waits.expectedPoolElectionTimeout(len(nodes)))
# Now all the nodes receive Commits
# The slow node will accept Commits and order the 3PC-batch in the old view
looper.runFor(waits.expectedOrderingTime(getNoInstances(len(nodes))))
# Now slow node receives ViewChangeDones
waitForViewChange(looper,
[slow_node],
expectedViewNo=view_no + 1,
customTimeout=waits.expectedPoolViewChangeStartedTimeout(len(nodes)))
wait_for_elections_done_on_given_nodes(looper,
[slow_node],
getRequiredInstances(len(nodes)),
timeout=waits.expectedPoolElectionTimeout(len(nodes)))
# Now slow node receives InstanceChanges but discards them because already
# started propagate primary to the same view.
# Finish request gracefully
sdk_get_reply(looper, request)
def test_pool_restart_now(
sdk_pool_handle, sdk_wallet_trustee, looper, tdir, tconf):
server, indicator = looper.loop.run_until_complete(
_createServer(
host=tconf.controlServiceHost,
port=tconf.controlServicePort
)
)
op = {
TXN_TYPE: POOL_RESTART,
ACTION: START,
}
req_obj = sdk_gen_request(op, identifier=sdk_wallet_trustee[1])
req = sdk_sign_and_submit_req_obj(looper,
sdk_pool_handle,
sdk_wallet_trustee,
req_obj)
is_reply_received = False
try:
req_json, resp = sdk_get_reply(looper, req, 100)
except Exception as ex:
assert "Timeout" in ex.args
_stopServer(server)
if is_reply_received:
_comparison_reply(resp, req_obj)
def sdk_write_context(looper, sdk_pool_handle, sdk_wallet_steward, context_array=[], name="", version=""):
_wh, did = sdk_wallet_steward
'''_, context_json = looper.loop.run_until_complete(
issuer_create_context(
did, name,
version, json.dumps(context_array)
))
'''
# create json
SET_CONTEXT = "200"
raw_json = {
'operation': {
'type': SET_CONTEXT,
'data': {
'name': name,
'version': version,
'context_array': context_array
}
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": 2,
}
set_context_txn_json = json.dumps(raw_json)
return json.dumps({'id': did + ':7:' + name + ':' + version}), \
sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, set_context_txn_json))[1]
def requests(looper, sdk_wallet_client, sdk_pool_handle):
requests = []
for i in range(5):
req = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
req, _ = sdk_get_reply(looper, req, timeout=sdk_eval_timeout(1, 4))
requests.append(req)
return requests
def sdk_write_context(looper,
sdk_pool_handle,
sdk_wallet_steward,
context=[],
name="",
version=""):
_wh, did = sdk_wallet_steward
# create json
raw_json = {
'operation': {
TXN_TYPE: SET_CONTEXT,
META: {
CONTEXT_NAME: name,
CONTEXT_VERSION: version,
RS_TYPE: CONTEXT_TYPE
},
DATA: context
},
"identifier": did,
"reqId": 12345678,
"protocolVersion": CURRENT_PROTOCOL_VERSION,
}
set_context_txn_json = json.dumps(raw_json)
return json.dumps({'id': did + ':' + MARKER_CONTEXT + ':' + name + ':' + version}), \
sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward, set_context_txn_json))[1]
def execute_attrib_txn(looper, sdk_pool_handle, sdk_wallet_steward, xhash, raw,
enc):
_, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_attrib_request(identifier, identifier, xhash, raw, enc))
return sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
def get_schema_json(looper, sdk_pool_handle, sdk_wallet_trustee):
wallet_handle, identifier = sdk_wallet_trustee
schema_json, _ = sdk_write_schema(looper, sdk_pool_handle, sdk_wallet_trustee)
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee, request))[1]
_, schema_json = looper.loop.run_until_complete(parse_get_schema_response(json.dumps(reply)))
return schema_json
def do_view_change_with_pending_request_and_one_fast_node(
fast_node, nodes, looper, sdk_pool_handle, sdk_wallet_client):
"""
Perform view change while processing request, with one node receiving commits much sooner than others.
With current implementation of view change this will result in corrupted state of fast node
"""
fast_stasher = fast_node.nodeIbStasher
slow_nodes = [n for n in nodes if n != fast_node]
slow_stashers = [n.nodeIbStasher for n in slow_nodes]
# Get last prepared certificate in pool
lpc = last_prepared_certificate(nodes)
# Get pool current view no
view_no = lpc[0]
# Delay all COMMITs
with delay_rules(slow_stashers, cDelay()):
with delay_rules(fast_stasher, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle,
sdk_wallet_client)
# Wait until this request is prepared on N-f nodes
looper.run(
eventually(check_last_prepared_certificate_on_quorum, nodes,
(lpc[0], lpc[1] + 1)))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Now commits are processed on fast node
# Wait until view change is complete
looper.run(
eventually(check_view_change_done, nodes, view_no + 1, timeout=60))
# Finish request gracefully
sdk_get_reply(looper, request)
def test_nym_reply_is_valid(looper, sdk_pool_handle, sdk_wallet_steward):
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
_, identifier = sdk_wallet_steward
request = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_nym_txn(reply['result']['txn'])
def sdk_write_schema(looper, sdk_pool_handle, sdk_wallet_client, multi_attribute=[], name="", version=""):
_, identifier = sdk_wallet_client
if multi_attribute:
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, name, version, json.dumps(multi_attribute)))
else:
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0", json.dumps(["first", "last"])))
request = looper.loop.run_until_complete(build_schema_request(identifier, schema_json))
return schema_json, \
sdk_get_reply(looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client, request))[1]
def req(request, looper, sdk_pool_handle, sdk_wallet_steward):
wallet_handle, identifier = sdk_wallet_steward
if request.param == "ATTRIB":
raw = json.dumps({'answer': 42})
request_json = looper.loop.run_until_complete(
build_attrib_request(identifier,
identifier,
raw=raw,
xhash=None,
enc=None))
elif request.param == "SCHEMA":
_, schema_json = looper.loop.run_until_complete(
issuer_create_schema(identifier, "name", "1.0",
json.dumps(["first", "last"])))
request_json = looper.loop.run_until_complete(
build_schema_request(identifier, schema_json))
elif request.param == "RS_SCHEMA":
rs_schema = {'@id': "fakeId234e", '@type': "0od"}
request_json = build_rs_schema_request(identifier, rs_schema,
"ISO18023_Drivers_License",
"1.1")
elif request.param == "CLAIM_DEF":
schema_json, _ = sdk_write_schema(looper, sdk_pool_handle,
sdk_wallet_steward)
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(
build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
_, schema_json = looper.loop.run_until_complete(
parse_get_schema_response(json.dumps(reply)))
_, definition_json = looper.loop.run_until_complete(
issuer_create_and_store_credential_def(
wallet_handle, identifier, schema_json, "some_tag", "CL",
json.dumps({"support_revocation": True})))
request_json = looper.loop.run_until_complete(
build_cred_def_request(identifier, definition_json))
elif request.param == "NYM":
idr, verkey = createHalfKeyIdentifierAndAbbrevVerkey()
request_json = looper.loop.run_until_complete(
build_nym_request(identifier, idr, verkey, None, None))
req_signed = looper.loop.run_until_complete(
sign_request(wallet_handle, identifier, request_json))
return Request(**json.loads(req_signed))
def sdk_write_rich_schema_object(looper, sdk_wallet_client, sdk_pool_handle,
txn_type, rs_id, rs_name, rs_version, rs_type,
rs_content):
request = sdk_build_rich_schema_request(looper,
sdk_wallet_client,
txn_type,
rs_id=rs_id,
rs_name=rs_name,
rs_version=rs_version,
rs_type=rs_type,
rs_content=json.dumps(rs_content))
return sdk_get_reply(
looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_client,
req))[1]
def do_view_change_with_pending_request_and_one_fast_node(fast_node,
nodes, looper, sdk_pool_handle, sdk_wallet_client):
"""
Perform view change while processing request, with one node receiving commits much sooner than others.
With current implementation of view change this will result in corrupted state of fast node
"""
fast_stasher = fast_node.nodeIbStasher
slow_nodes = [n for n in nodes if n != fast_node]
slow_stashers = [n.nodeIbStasher for n in slow_nodes]
# Get last prepared certificate in pool
lpc = last_prepared_certificate(nodes)
# Get pool current view no
view_no = lpc[0]
# Delay all COMMITs
with delay_rules(slow_stashers, cDelay()):
with delay_rules(fast_stasher, cDelay()):
# Send request
request = sdk_send_random_request(looper, sdk_pool_handle, sdk_wallet_client)
# Wait until this request is prepared on N-f nodes
looper.run(eventually(check_last_prepared_certificate_on_quorum, nodes, (lpc[0], lpc[1] + 1)))
# Trigger view change
for n in nodes:
n.view_changer.on_master_degradation()
# Now commits are processed on fast node
# Wait until view change is complete
looper.run(eventually(check_view_change_done, nodes, view_no + 1, timeout=60))
# Finish request gracefully
sdk_get_reply(looper, request)
def test_rich_schema_object_reply_is_valid(looper, sdk_pool_handle,
sdk_wallet_steward, txn_type,
rs_type, content, rs_id):
request = sdk_build_rich_schema_request(looper,
sdk_wallet_steward,
txn_type=txn_type,
rs_id=rs_id,
rs_name=randomString(),
rs_version='1.0',
rs_type=rs_type,
rs_content=json.dumps(content))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_steward,
request))[1]
validate_write_reply(reply)
validate_rich_schema_txn(reply['result']['txn'], txn_type)
def large_schema_json(looper, sdk_pool_handle, sdk_wallet_trustee):
wallet_handle, identifier = sdk_wallet_trustee
attrs = [
randomString(size=NAME_FIELD_LIMIT)
for _ in range(SCHEMA_ATTRIBUTES_LIMIT)
]
schema_json, _ = sdk_write_schema(looper,
sdk_pool_handle,
sdk_wallet_trustee,
multi_attribute=attrs,
name="name_large",
version="2.0")
schema_id = json.loads(schema_json)['id']
request = looper.loop.run_until_complete(
build_get_schema_request(identifier, schema_id))
reply = sdk_get_reply(
looper,
sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet_trustee,
request))[1]
_, schema_json = looper.loop.run_until_complete(
parse_get_schema_response(json.dumps(reply)))
return schema_json
def test_sdk_new_client_send(looper, sdk_pool_handle, sdk_wallet_new_client):
resp_task = sdk_send_random_request(looper, sdk_pool_handle,
sdk_wallet_new_client)
_, j_resp = sdk_get_reply(looper, resp_task)
assert j_resp['result']
def do_view_change_with_delayed_commits_and_node_restarts(
fast_nodes,
slow_nodes,
nodes_to_restart,
old_view_no,
old_last_ordered,
looper,
sdk_pool_handle,
sdk_wallet_client,
tconf,
tdir,
all_plugins_path,
wait_for_catchup=False):
"""
Delays commits without processing on `slow_nodes`, restarts `nodes_to_restart`, triggers view change, and confirms
that view changed completed successfully and that the ledgers are consistent and in sync.
:param fast_nodes: Nodes that will order the requests
:param slow_nodes: Nodes whose commits will be delay, and that will not order the requests
:param nodes_to_restart: Nodes that will be restarted
:param old_view_no: View that we started from
:param old_last_ordered: Last ordered 3pc txn before we did any requests
:param wait_for_catchup: Should we wait for restarted nodes to finish catchup
"""
nodes = fast_nodes + slow_nodes
slow_stashers = [slow_node.nodeIbStasher for slow_node in slow_nodes]
# Delay commits on `slow_nodes`
with delay_rules_without_processing(slow_stashers, cDelay()):
request = sdk_send_random_request(looper, sdk_pool_handle,
sdk_wallet_client)
# Check that all of the nodes except the slows one ordered the request
looper.run(
eventually(check_last_ordered, fast_nodes,
(old_view_no, old_last_ordered[1] + 1)))
looper.run(eventually(check_last_ordered, slow_nodes,
old_last_ordered))
# Restart nodes
for node in nodes_to_restart:
disconnect_node_and_ensure_disconnected(looper,
nodes,
node,
timeout=len(nodes_to_restart),
stopNode=True)
looper.removeProdable(node)
nodes.remove(node)
restarted_node = start_stopped_node(node, looper, tconf, tdir,
all_plugins_path)
nodes.append(restarted_node)
looper.runFor(waits.expectedNodeStartUpTimeout())
looper.run(checkNodesConnected(nodes))
if wait_for_catchup:
ensure_all_nodes_have_same_data(looper, nodes)
# Trigger view change on all nodes
for node in nodes:
node.view_changer.on_master_degradation()
assert len(nodes) == len(slow_nodes) + len(fast_nodes)
# Assert that view change was successful and that ledger data is consistent
waitForViewChange(looper,
nodes,
expectedViewNo=(old_view_no + 1),
customTimeout=waits.expectedPoolViewChangeStartedTimeout(
len(nodes)))
ensureElectionsDone(looper=looper, nodes=nodes)
ensure_all_nodes_have_same_data(looper, nodes)
sdk_get_reply(looper, request)
sdk_ensure_pool_functional(looper, nodes, sdk_wallet_client,
sdk_pool_handle)
def sdk_update_node_data(looper, sdk_pool, sdk_wallet_steward, node,
node_data):
node_req = sdk_send_update_node(sdk_wallet_steward, node, node_data)
_, j_resp = sdk_get_reply(looper, node_req)
assert j_resp['result']
def sdk_write_rs_schema(looper, sdk_pool_handle, sdk_wallet, request):
return sdk_get_reply(
looper, sdk_sign_and_submit_req(sdk_pool_handle, sdk_wallet,
request))[1]
def successful_op(looper, op, sdk_wallet, sdk_pool_handle):
req_obj = sdk_gen_request(op, identifier=sdk_wallet[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle,
sdk_wallet, req_obj)
sdk_get_reply(looper, req)
def successful_op(looper, op, sdk_wallet, sdk_pool_handle):
req_obj = sdk_gen_request(op, identifier=sdk_wallet[1])
req = sdk_sign_and_submit_req_obj(looper, sdk_pool_handle, sdk_wallet,
req_obj)
sdk_get_reply(looper, req)
