def testClientConnectAfterRestart(looper, txnPoolNodeSet, tdirWithPoolTxns):
cname = "testClient" + randomString(5)
newClient, _ = genTestClient(tmpdir=tdirWithPoolTxns, name=cname,
usePoolLedger=True)
logger.debug("{} starting at {}".format(newClient, newClient.nodestack.ha))
looper.add(newClient)
logger.debug("Public keys of client {} {}".format(
newClient.nodestack.local.priver.keyhex,
newClient.nodestack.local.priver.pubhex))
logger.debug("Signer keys of client {} {}".format(
newClient.nodestack.local.signer.keyhex,
newClient.nodestack.local.signer.verhex))
looper.run(newClient.ensureConnectedToNodes())
newClient.stop()
looper.removeProdable(newClient)
newClient, _ = genTestClient(tmpdir=tdirWithPoolTxns, name=cname,
usePoolLedger=True)
logger.debug("{} again starting at {}".format(newClient,
newClient.nodestack.ha))
looper.add(newClient)
logger.debug("Public keys of client {} {}".format(
newClient.nodestack.local.priver.keyhex,
newClient.nodestack.local.priver.pubhex))
logger.debug("Signer keys of client {} {}".format(
newClient.nodestack.local.signer.keyhex,
newClient.nodestack.local.signer.verhex))
looper.run(newClient.ensureConnectedToNodes())
def testClientConnectAfterRestart(looper, txnPoolNodeSet, tdirWithPoolTxns):
cname = "testClient" + randomString(5)
newClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
name=cname,
usePoolLedger=True)
logger.debug("{} starting at {}".format(newClient, newClient.nodestack.ha))
looper.add(newClient)
logger.debug("Public keys of client {} {}".format(
newClient.nodestack.prihex, newClient.nodestack.pubhex))
logger.debug("Signer keys of client {} {}".format(
newClient.nodestack.keyhex, newClient.nodestack.verhex))
looper.run(newClient.ensureConnectedToNodes())
newClient.stop()
looper.removeProdable(newClient)
newClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
name=cname,
usePoolLedger=True)
logger.debug("{} again starting at {}".format(newClient,
newClient.nodestack.ha))
looper.add(newClient)
logger.debug("Public keys of client {} {}".format(
newClient.nodestack.prihex, newClient.nodestack.pubhex))
logger.debug("Signer keys of client {} {}".format(
newClient.nodestack.keyhex, newClient.nodestack.verhex))
looper.run(newClient.ensureConnectedToNodes())
async def go(ctx):
client1, wallet = genTestClient(ctx.nodeset, tmpdir=ctx.tmpdir)
# remove the client's ability to sign
assert wallet.defaultId
ctx.looper.add(client1)
await client1.ensureConnectedToNodes()
request = wallet.signOp(op=randomOperation())
request.signature = None
request = client1.submitReqs(request)[0]
with pytest.raises(AssertionError):
for node in ctx.nodeset:
await eventually(checkLastClientReqForNode,
node,
request,
retryWait=1,
timeout=10)
for n in ctx.nodeset:
params = n.spylog.getLastParams(Node.handleInvalidClientMsg)
ex = params['ex']
_, frm = params['wrappedMsg']
assert isinstance(ex, EmptySignature)
assert frm == client1.stackName
params = n.spylog.getLastParams(Node.discard)
reason = params["reason"]
(msg, frm) = params["msg"]
assert msg == request.__dict__
assert frm == client1.stackName
assert "EmptySignature" in reason
def testClientReconnectUsingDifferentHa(looper, txnPoolNodeSet,
tdirWithPoolTxns, poolTxnClientData):
"""
Client should not be able to connect to nodes even after it has changed
its HA. Since running on a local environment, only checking change of port.
Dont know how to change IP.
:return:
"""
# TODO: Check for change of IP too
client, wallet = buildPoolClientAndWallet(poolTxnClientData,
tdirWithPoolTxns)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
basedirpath = client.basedirpath
client.stop()
looper.removeProdable(client)
# Removing RAET keep directory otherwise the client will use the same port
# since it will a directory of its name in the keep
shutil.rmtree(os.path.join(basedirpath, client.name), ignore_errors=True)
ha = genHa()
client, _ = genTestClient(txnPoolNodeSet,
identifier=wallet.defaultId,
ha=ha,
tmpdir=tdirWithPoolTxns,
usePoolLedger=True,
name=client.name)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
def testClientReconnectUsingDifferentHa(looper, txnPoolNodeSet,
tdirWithPoolTxns,
tdirWithClientPoolTxns,
poolTxnClientData):
"""
Client should not be able to connect to nodes even after it has changed
its HA. Since running on a local environment, only checking change of port.
Dont know how to change IP.
:return:
"""
# TODO: Check for change of IP too
client, wallet = buildPoolClientAndWallet(poolTxnClientData,
tdirWithClientPoolTxns)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
keys_dir = os.path.join(client.keys_dir, client.name)
client.stop()
looper.removeProdable(client)
ha = genHa()
client, _ = genTestClient(txnPoolNodeSet,
identifier=wallet.defaultId,
ha=ha,
tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True,
name=client.name)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
async def go(ctx):
client1, wallet = genTestClient(ctx.nodeset, tmpdir=ctx.tmpdir)
# remove the client's ability to sign
assert wallet.defaultId
ctx.looper.add(client1)
await client1.ensureConnectedToNodes()
request = wallet.signOp(op=randomOperation())
request.signature = None
request = client1.submitReqs(request)[0]
with pytest.raises(AssertionError):
for node in ctx.nodeset:
await eventually(
checkLastClientReqForNode, node, request,
retryWait=1, timeout=10)
for n in ctx.nodeset:
params = n.spylog.getLastParams(Node.handleInvalidClientMsg)
ex = params['ex']
_, frm = params['wrappedMsg']
assert isinstance(ex, EmptySignature)
assert frm == client1.stackName
params = n.spylog.getLastParams(Node.discard)
reason = params["reason"]
(msg, frm) = params["msg"]
assert msg == request.__dict__
assert frm == client1.stackName
assert "EmptySignature" in reason
def makeClient(id):
client, wallet = genTestClient(nodeSet,
tmpdir=tdir,
name="client-{}".format(id))
looper.add(client)
looper.run(client.ensureConnectedToNodes())
return client, wallet
def testClientReconnectUsingDifferentHa(looper, txnPoolNodeSet,
tdirWithPoolTxns, poolTxnClientData):
"""
Client should not be able to connect to nodes even after it has changed
its HA. Since running on a local environment, only checking change of port.
Dont know how to change IP.
:return:
"""
# TODO: Check for change of IP too
client, wallet = buildPoolClientAndWallet(poolTxnClientData,
tdirWithPoolTxns)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
basedirpath = client.basedirpath
looper.removeProdable(client)
# Removing RAET keep directory otherwise the client will use the same port
# since it will a directory of its name in the keep
shutil.rmtree(os.path.join(basedirpath, client.name), ignore_errors=True)
ha = genHa()
client, _ = genTestClient(txnPoolNodeSet, identifier=wallet.defaultId,
ha=ha, tmpdir=tdirWithPoolTxns,
usePoolLedger=True, name=client.name)
looper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, client,
*txnPoolNodeSet)
def makeClient(id):
client, wallet = genTestClient(nodeSet,
tmpdir=tdir,
name="client-{}".format(id))
looper.add(client)
looper.run(client.ensureConnectedToNodes())
return client, wallet
async def go(ctx):
client1, wallet = genTestClient(ctx.nodeset, tmpdir=ctx.tmpdir)
# remove the client's ability to sign
assert wallet.defaultId
ctx.looper.add(client1)
await client1.ensureConnectedToNodes()
request = wallet.signOp(op=randomOperation())
request.signature = None
request = client1.submitReqs(request)[0][0]
timeout = waits.expectedClientRequestPropagationTime(nodeCount)
with pytest.raises(AssertionError):
for node in ctx.nodeset:
await eventually(checkLastClientReqForNode,
node,
request,
retryWait=1,
timeout=timeout)
for n in ctx.nodeset:
params = n.spylog.getLastParams(Node.handleInvalidClientMsg)
ex = params['ex']
msg, _ = params['wrappedMsg']
assert isinstance(ex, MissingSignature)
assert msg.get(f.IDENTIFIER.nm) == request.identifier
params = n.spylog.getLastParams(Node.discard)
reason = params["reason"]
(msg, frm) = params["msg"]
assert msg == request.as_dict
assert msg.get(f.IDENTIFIER.nm) == request.identifier
assert "MissingSignature" in reason
def changeNodeHa(looper, txnPoolNodeSet, tdirWithClientPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary, tdir):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if shouldBePrimary == n.has_master_primary:
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".format(
subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed,
basedir=tdirWithClientPoolTxns)
waitForSufficientRepliesForRequests(looper, stewardClient,
requests=[req])
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
config_helper = PNodeConfigHelper(subjectedNode.name, tconf, chroot=tdir)
restartedNode = TestNode(subjectedNode.name,
config_helper=config_helper,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, customTimeout=70))
electionTimeout = waits.expectedPoolElectionTimeout(
nodeCount=len(txnPoolNodeSet),
numOfReelections=3)
ensureElectionsDone(looper,
txnPoolNodeSet,
retryWait=1,
customTimeout=electionTimeout)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=DidSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(
looper, stewardWallet, stewardClient, 8)
def changeNodeHa(looper, txnPoolNodeSet, tdirWithClientPoolTxns,
tconf, shouldBePrimary, tdir,
sdk_pool_handle, sdk_wallet_stewards):
# prepare new ha for node and client stack
subjectedNode = None
node_index = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if shouldBePrimary == n.has_master_primary:
subjectedNode = n
node_index = nodeIndex
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".format(
subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
# change HA
sdk_wallet_steward = sdk_wallet_stewards[node_index]
node_dest = hexToFriendly(subjectedNode.nodestack.verhex)
sdk_send_update_node(looper, sdk_wallet_steward,
sdk_pool_handle,
node_dest, subjectedNode.name,
nodeStackNewHA[0], nodeStackNewHA[1],
clientStackNewHA[0], clientStackNewHA[1],
services=[VALIDATOR])
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
config_helper = PNodeConfigHelper(subjectedNode.name, tconf, chroot=tdir)
restartedNode = TestNode(subjectedNode.name,
config_helper=config_helper,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, customTimeout=70))
sdk_pool_refresh(looper, sdk_pool_handle)
electionTimeout = waits.expectedPoolElectionTimeout(
nodeCount=len(txnPoolNodeSet),
numOfReelections=3)
ensureElectionsDone(looper,
txnPoolNodeSet,
retryWait=1,
customTimeout=electionTimeout)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithClientPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
sdk_send_random_and_check(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_steward,
8)
def client_and_wallet(txnPoolNodesLooper, tdirWithPoolTxns, txnPoolNodeSet):
client, wallet = genTestClient(tmpdir=tdirWithPoolTxns,
nodes=txnPoolNodeSet,
name='reader',
usePoolLedger=True)
txnPoolNodesLooper.add(client)
ensureClientConnectedToNodesAndPoolLedgerSame(txnPoolNodesLooper, client,
*txnPoolNodeSet)
return client, wallet
async def go(ctx):
for n in ctx.nodeset:
n.nodestack.keep.auto = AutoMode.never
nodestacksVersion = {k: v.ha for k, v in ctx.nodeset.nodeReg.items()}
client1, _ = genTestClient(nodeReg=nodestacksVersion, tmpdir=ctx.tmpdir)
ctx.looper.add(client1)
with pytest.raises(NotConnectedToAny):
await client1.ensureConnectedToNodes()
async def go(ctx):
for n in ctx.nodeset:
n.nodestack.keep.auto = AutoMode.never
nodestacksVersion = {k: v.ha for k, v in ctx.nodeset.nodeReg.items()}
client1, _ = genTestClient(nodeReg=nodestacksVersion, tmpdir=ctx.tmpdir)
ctx.looper.add(client1)
with pytest.raises(NotConnectedToAny):
await client1.ensureConnectedToNodes()
def testReplyReceivedOnlyByClientWhoSentRequest(looper, nodeSet, tdir,
client1, wallet1):
newClient, _ = genTestClient(nodeSet, tmpdir=tdir)
looper.add(newClient)
looper.run(newClient.ensureConnectedToNodes())
client1InboxSize = len(client1.inBox)
newClientInboxSize = len(newClient.inBox)
sendReqsToNodesAndVerifySuffReplies(looper, wallet1, newClient, 1)
assert len(client1.inBox) == client1InboxSize
assert len(newClient.inBox) > newClientInboxSize
def createClientSendMessageAndRemove(looper,
nodeSet,
tdir,
wallet,
name=None,
tries=None,
sighex=None):
client, _ = genTestClient(nodeSet, tmpdir=tdir, name=name, sighex=sighex)
clientSendMessageAndRemove(client, looper, wallet, tries)
return client
def testReplyReceivedOnlyByClientWhoSentRequest(looper, nodeSet, tdir, client1,
wallet1):
newClient, _ = genTestClient(nodeSet, tmpdir=tdir)
looper.add(newClient)
looper.run(newClient.ensureConnectedToNodes())
client1InboxSize = len(client1.inBox)
newClientInboxSize = len(newClient.inBox)
sendReqsToNodesAndVerifySuffReplies(looper, wallet1, newClient, 1)
assert len(client1.inBox) == client1InboxSize
assert len(newClient.inBox) > newClientInboxSize
def buildPoolClientAndWallet(clientData, tempDir, clientClass=None, walletClass=None):
walletClass = walletClass or Wallet
clientClass = clientClass or TestClient
name, sigseed = clientData
w = walletClass(name)
w.addIdentifier(signer=DidSigner(seed=sigseed))
client, _ = genTestClient(name=name, identifier=w.defaultId,
tmpdir=tempDir, usePoolLedger=True,
testClientClass=clientClass)
return client, w
def changeNodeHa(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if (shouldBePrimary and n.primaryReplicaNo == 0) or \
(not shouldBePrimary and n.primaryReplicaNo != 0):
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".
format(subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed)
f = getMaxFailures(len(stewardClient.nodeReg))
looper.run(eventually(checkSufficientRepliesRecvd, stewardClient.inBox,
req.reqId, f, retryWait=1, timeout=20))
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
restartedNode = TestNode(subjectedNode.name, basedirpath=tdirWithPoolTxns,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, overrideTimeout=70))
ensureElectionsDone(looper, txnPoolNodeSet, retryWait=1, timeout=10)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=SimpleSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(looper, stewardWallet, stewardClient, 8)
looper.run(eventually(checkIfGenesisPoolTxnFileUpdated, *txnPoolNodeSet,
stewardClient, anotherClient, retryWait=1,
timeout=10))
looper.removeProdable(stewardClient)
async def aSetupClient(looper: Looper,
nodes: Sequence[TestNode] = None,
nodeReg=None,
tmpdir=None):
"""
async version of above
"""
client1 = genTestClient(nodes=nodes, nodeReg=nodeReg, tmpdir=tmpdir)
looper.add(client1)
await client1.ensureConnectedToNodes()
return client1
def buildPoolClientAndWallet(clientData, tempDir, clientClass=None,
walletClass=None):
walletClass = walletClass or Wallet
clientClass = clientClass or TestClient
name, sigseed = clientData
w = walletClass(name)
w.addIdentifier(signer=SimpleSigner(seed=sigseed))
client, _ = genTestClient(name=name, identifier=w.defaultId,
tmpdir=tempDir, usePoolLedger=True,
testClientClass=clientClass)
return client, w
def changeNodeHa(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnData, poolTxnStewardNames, tconf, shouldBePrimary):
# prepare new ha for node and client stack
subjectedNode = None
stewardName = None
stewardsSeed = None
for nodeIndex, n in enumerate(txnPoolNodeSet):
if (shouldBePrimary and n.primaryReplicaNo == 0) or \
(not shouldBePrimary and n.primaryReplicaNo != 0):
subjectedNode = n
stewardName = poolTxnStewardNames[nodeIndex]
stewardsSeed = poolTxnData["seeds"][stewardName].encode()
break
nodeStackNewHA, clientStackNewHA = genHa(2)
logger.debug("change HA for node: {} to {}".
format(subjectedNode.name, (nodeStackNewHA, clientStackNewHA)))
nodeSeed = poolTxnData["seeds"][subjectedNode.name].encode()
# change HA
stewardClient, req = changeHA(looper, tconf, subjectedNode.name, nodeSeed,
nodeStackNewHA, stewardName, stewardsSeed)
f = getMaxFailures(len(stewardClient.nodeReg))
looper.run(eventually(checkSufficientRepliesRecvd, stewardClient.inBox,
req.reqId, f, retryWait=1, timeout=20))
# stop node for which HA will be changed
subjectedNode.stop()
looper.removeProdable(subjectedNode)
# start node with new HA
restartedNode = TestNode(subjectedNode.name, basedirpath=tdirWithPoolTxns,
config=tconf, ha=nodeStackNewHA,
cliha=clientStackNewHA)
looper.add(restartedNode)
txnPoolNodeSet[nodeIndex] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet, overrideTimeout=70))
ensureElectionsDone(looper, txnPoolNodeSet, retryWait=1, timeout=10)
# start client and check the node HA
anotherClient, _ = genTestClient(tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
looper.add(anotherClient)
looper.run(eventually(anotherClient.ensureConnectedToNodes))
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=SimpleSigner(seed=stewardsSeed))
sendReqsToNodesAndVerifySuffReplies(looper, stewardWallet, stewardClient, 8)
looper.run(eventually(checkIfGenesisPoolTxnFileUpdated, *txnPoolNodeSet,
stewardClient, anotherClient, retryWait=1,
timeout=10))
async def go(ctx):
nodestacksVersion = {k: v.ha for k, v in ctx.nodeset.nodeReg.items()}
client1, _ = genTestClient(nodeReg=nodestacksVersion,
tmpdir=ctx.tmpdir)
for node in ctx.nodeset:
stack = node.nodestack
args = (client1.name, stack.name, ctx.tmpdir, stack.verhex, True)
initRemoteKeys(*args)
ctx.looper.add(client1)
with pytest.raises(NotConnectedToAny):
await client1.ensureConnectedToNodes()
def setupClient(looper: Looper,
nodes: Sequence[TestNode] = None,
nodeReg=None,
tmpdir=None,
identifier=None,
verkey=None):
client1, wallet = genTestClient(nodes=nodes,
nodeReg=nodeReg,
tmpdir=tmpdir,
identifier=identifier,
verkey=verkey)
looper.add(client1)
looper.run(client1.ensureConnectedToNodes())
return client1, wallet
def testClientConnectToRestartedNodes(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnClientNames, poolTxnData, tconf,
poolTxnNodeNames, allPluginsPath):
name = poolTxnClientNames[-1]
seed = poolTxnData["seeds"][name]
newClient, w = genTestClient(tmpdir=tdirWithPoolTxns,
nodes=txnPoolNodeSet,
name=name,
usePoolLedger=True)
looper.add(newClient)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 1, 1)
for node in txnPoolNodeSet:
node.stop()
looper.removeProdable(node)
# looper.run(newClient.ensureDisconnectedToNodes(timeout=60))
txnPoolNodeSet = []
for nm in poolTxnNodeNames:
node = TestNode(nm,
basedirpath=tdirWithPoolTxns,
config=tconf,
pluginPaths=allPluginsPath)
looper.add(node)
txnPoolNodeSet.append(node)
looper.run(checkNodesConnected(txnPoolNodeSet))
ensureElectionsDone(looper=looper,
nodes=txnPoolNodeSet,
retryWait=1,
timeout=10)
def chk():
for node in txnPoolNodeSet:
assert node.isParticipating
looper.run(eventually(chk, retryWait=1, timeout=10))
bootstrapClientKeys(w.defaultId, w.getVerkey(), txnPoolNodeSet)
req = sendRandomRequest(w, newClient)
checkSufficientRepliesForRequests(looper,
newClient, [
req,
],
timeoutPerReq=10)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 1, 1)
def testClientConnectToRestartedNodes(looper, txnPoolNodeSet, tdirWithPoolTxns,
tdir, tdirWithClientPoolTxns,
poolTxnClientNames, poolTxnData, tconf,
poolTxnNodeNames, allPluginsPath):
name = poolTxnClientNames[-1]
newClient, w = genTestClient(tmpdir=tdirWithClientPoolTxns,
nodes=txnPoolNodeSet,
name=name,
usePoolLedger=True)
looper.add(newClient)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 1, 1)
for node in txnPoolNodeSet:
node.stop()
looper.removeProdable(node)
# looper.run(newClient.ensureDisconnectedToNodes(timeout=60))
txnPoolNodeSet = []
for nm in poolTxnNodeNames:
config_helper = PNodeConfigHelper(nm, tconf, chroot=tdir)
node = TestNode(nm,
ledger_dir=config_helper.ledger_dir,
keys_dir=config_helper.keys_dir,
genesis_dir=config_helper.genesis_dir,
plugins_dir=config_helper.plugins_dir,
config=tconf,
pluginPaths=allPluginsPath)
looper.add(node)
txnPoolNodeSet.append(node)
looper.run(checkNodesConnected(txnPoolNodeSet))
ensureElectionsDone(looper=looper, nodes=txnPoolNodeSet)
def chk():
for node in txnPoolNodeSet:
assert node.isParticipating
timeout = waits.expectedPoolGetReadyTimeout(len(txnPoolNodeSet))
looper.run(eventually(chk, retryWait=1, timeout=timeout))
bootstrapClientKeys(w.defaultId, w.getVerkey(), txnPoolNodeSet)
req = sendRandomRequest(w, newClient)
waitForSufficientRepliesForRequests(looper, newClient, requests=[req])
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 3, 1)
def testClientConnectToRestartedNodes(looper, txnPoolNodeSet, tdirWithPoolTxns,
poolTxnClientNames, poolTxnData, tconf,
poolTxnNodeNames,
allPluginsPath):
name = poolTxnClientNames[-1]
seed = poolTxnData["seeds"][name]
newClient, w = genTestClient(tmpdir=tdirWithPoolTxns, nodes=txnPoolNodeSet,
name=name, usePoolLedger=True)
looper.add(newClient)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 1, 1)
for node in txnPoolNodeSet:
node.stop()
looper.removeProdable(node)
# looper.run(newClient.ensureDisconnectedToNodes(timeout=60))
txnPoolNodeSet = []
for nm in poolTxnNodeNames:
node = TestNode(nm, basedirpath=tdirWithPoolTxns,
config=tconf, pluginPaths=allPluginsPath)
looper.add(node)
txnPoolNodeSet.append(node)
looper.run(checkNodesConnected(txnPoolNodeSet))
ensureElectionsDone(looper=looper, nodes=txnPoolNodeSet, retryWait=1,
timeout=10)
def chk():
for node in txnPoolNodeSet:
assert node.isParticipating
looper.run(eventually(chk, retryWait=1, timeout=10))
bootstrapClientKeys(w.defaultId, w.getVerkey(), txnPoolNodeSet)
req = sendRandomRequest(w, newClient)
checkSufficientRepliesForRequests(looper, newClient, [req, ],
timeoutPerReq=10)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newClient,
*txnPoolNodeSet)
sendReqsToNodesAndVerifySuffReplies(looper, w, newClient, 1, 1)
def clientAndWallet1(looper, nodeSet, tdir, up):
return genTestClient(nodeSet, tmpdir=tdir)
def clientAndWallet1(looper, nodeSet, tdir, up):
return genTestClient(nodeSet, tmpdir=tdir)
def clientAndWallet1(looper, nodeSet, tdir, up):
client, wallet = genTestClient(nodeSet, tmpdir=tdir)
yield client, wallet
client.stop()
def poolTxnClient(tdirWithPoolTxns, tdirWithDomainTxns, txnPoolNodeSet):
return genTestClient(txnPoolNodeSet,
tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
def poolTxnClient(tdirWithPoolTxns, tdirWithDomainTxns, txnPoolNodeSet):
return genTestClient(txnPoolNodeSet, tmpdir=tdirWithPoolTxns,
usePoolLedger=True)
