def testZStackSendRecvHugeDataUnderLimit(set_info_log_level, tdir, looper, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
# we use json serializer now, so final form will be {'k':'vvv...vvv'}
# so here we try to prepare exactly tconf.MSG_LEN_LIMIT bytes after serialization
msg = {'k': 'v' * (tconf.MSG_LEN_LIMIT - len("{'k':''}"))}
betaHandler = [False]
def recvHandlerAlpha(wrpMsg):
pass
def recvHandlerBeta(wrpMsg):
rmsg, frm = wrpMsg
betaHandler[0] = True
assert frm == 'Alpha'
assert rmsg == msg
alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerAlpha, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=None)
beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerBeta, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=None)
assert len(alpha.serializeMsg(msg)) == tconf.MSG_LEN_LIMIT
prepStacks(looper, *(alpha, beta), connect=True, useKeys=True)
stat = alpha.send(msg, beta.name)
assert stat[0] is True
looper.runFor(5)
assert betaHandler[0] is True
def clientstack(tdir, looper, alpha_handler):
names = ['ClientA', 'Alpha']
genKeys(tdir, names)
aseed = randomSeed()
cseed = randomSeed()
stackParams = {
"name": names[0],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
timer = MockTimer(0)
client = ClientZStack(stackParams, alpha_handler.handle, cseed, False,
timer=timer)
stackParams = {
"name": names[1],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
timer = MockTimer(0)
alpha = SimpleZStack(stackParams, alpha_handler, aseed, True,
timer=timer)
amotor = SMotor(alpha)
looper.add(amotor)
cmotor = SMotor(client)
looper.add(cmotor)
return alpha, client
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(
seed=randomString(32).encode('utf-8')))
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
_, clientPort = genHa()
client = clientClass(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def testRaetPreSharedKeysPromiscous(tdir):
alphaSigner = NaclSigner()
betaSigner = NaclSigner()
logger.debug("Alpha's verkey {}".format(alphaSigner.verhex))
logger.debug("Beta's verkey {}".format(betaSigner.verhex))
alpha = RoadStack(name='alpha',
ha=genHa(),
sigkey=alphaSigner.keyhex,
auto=AutoMode.always,
basedirpath=tdir)
beta = RoadStack(name='beta',
ha=genHa(),
sigkey=betaSigner.keyhex,
main=True,
auto=AutoMode.always,
basedirpath=tdir)
try:
betaRemote = RemoteEstate(stack=alpha, ha=beta.ha,
verkey=betaSigner.verhex)
alpha.addRemote(betaRemote)
alpha.allow(uid=betaRemote.uid, cascade=True)
handshake(alpha, beta)
sendMsgs(alpha, beta, betaRemote)
finally:
cleanup(alpha, beta)
def getPoolTxnData(nodeAndClientInfoFilePath, poolId, newPoolTxnNodeNames):
data={}
data["seeds"]={}
data["txns"]=[]
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" * (32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM: stewardSigner.verkey,
ROLE: STEWARD, TXN_TYPE: NYM,
ALIAS: poolId + "Steward" + str(index),
TXN_ID: sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
data["txns"].append({
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID: sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
})
return data
def testManyMessages(set_info_log_level, tdir, looper, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
betaMsgHandler = CounterMsgsHandler()
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=betaMsgHandler.handler,
restricted=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
looper.runFor(1)
msgNum = BIG_NUM_OF_MSGS
msgSender = MessageSender(msgNum, alpha, beta.name)
looper.add(msgSender)
def checkAllReceived():
assert msgSender.sentMsgCount == msgNum
assert betaMsgHandler.receivedMsgCount == msgNum
looper.run(eventually(checkAllReceived,
retryWait=1,
timeout=60))
def registry():
return {
'Alpha': genHa(),
'Beta': genHa(),
'Gamma': genHa(),
'Delta': genHa()
}
def testMessageQuota(tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
betaMsgHandler = CollectingMsgsHandler()
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=betaMsgHandler.handler,
restricted=True,
onlyListener=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
messages = []
numMessages = 150 * beta.listenerQuota
for i in range(numMessages):
msg = json.dumps({'random': randomSeed().decode()}).encode()
if alpha.send(msg, beta.name):
messages.append(json.loads(msg.decode()))
def checkAllReceived():
assert len(messages) == len(betaMsgHandler.receivedMessages)
assert messages == betaMsgHandler.receivedMessages
looper.run(eventually(checkAllReceived, retryWait=0.5, timeout=5))
def testZStackSendRecvHugeDataUnderLimit(set_info_log_level, tdir, looper, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
# we use json serializer now, so final form will be {'k':'vvv...vvv'}
# so here we try to prepare exactly tconf.MSG_LEN_LIMIT bytes after serialization
msg = {'k': 'v' * (tconf.MSG_LEN_LIMIT - len("{'k':''}"))}
betaHandler = [False]
def recvHandlerAlpha(wrpMsg):
pass
def recvHandlerBeta(wrpMsg):
rmsg, frm = wrpMsg
betaHandler[0] = True
assert frm == 'Alpha'
assert rmsg == msg
alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerAlpha, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=None)
beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerBeta, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=None)
assert len(alpha.serializeMsg(msg)) == tconf.MSG_LEN_LIMIT
prepStacks(looper, *(alpha, beta), connect=True, useKeys=True)
stat = alpha.send(msg, beta.name)
assert stat[0] is True
looper.runFor(5)
assert betaHandler[0] is True
def testMessageQuota(tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
receivedMessages = []
betaMshHandler = makeHandler(receivedMessages)
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=betaMshHandler,
restricted=True,
onlyListener=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
messages = []
numMessages = 100 * beta.listenerQuota
for i in range(numMessages):
msg = json.dumps({'random': randomSeed().decode()}).encode()
messages.append(json.loads(msg.decode()))
alpha.send(msg, beta.name)
looper.runFor(2)
assert messages == receivedMessages
def testPromiscuousConnection(tdir, keysAndNames):
# Simulating node to client connection
alphaSighex, alphaPrikey, alphaVerhex, alphaPubkey, alphaName, betaSighex, \
betaPrikey, betaVerhex, betaPubkey, betaName = keysAndNames
alpha = RoadStack(name=alphaName,
ha=genHa(),
sigkey=alphaSighex,
prikey=hexlify(alphaPrikey),
auto=AutoMode.always,
basedirpath=tdir)
beta = RoadStack(name=betaName,
ha=genHa(),
main=True,
sigkey=betaSighex,
prikey=hexlify(betaPrikey),
auto=AutoMode.always,
basedirpath=tdir)
try:
betaRemote = RemoteEstate(stack=alpha, ha=beta.ha)
alpha.addRemote(betaRemote)
alpha.join(uid=betaRemote.uid, cascade=True)
handshake(alpha, beta)
sendMsgs(alpha, beta, betaRemote)
finally:
cleanup(alpha, beta)
def testMessageQuota(set_info_log_level, tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
betaMsgHandler = CollectingMsgsHandler()
alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=betaMsgHandler.handler,
restricted=True, onlyListener=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
messages = []
numMessages = 150 * beta.listenerQuota
for i in range(numMessages):
msg = json.dumps({'random': randomSeed().decode()}).encode()
if alpha.send(msg, beta.name):
messages.append(json.loads(msg.decode()))
def checkAllReceived():
assert len(messages) == len(betaMsgHandler.receivedMessages)
assert messages == betaMsgHandler.receivedMessages
looper.run(eventually(checkAllReceived, retryWait=0.5,
timeout=5))
def getPoolTxnData(nodeAndClientInfoFilePath, poolId, newPoolTxnNodeNames):
data={}
data["seeds"]={}
data["txns"]=[]
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" * (32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM: stewardSigner.verkey,
ROLE: STEWARD, TXN_TYPE: NYM,
ALIAS: poolId + "Steward" + str(index),
TXN_ID: sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
data["txns"].append({
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID: sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
})
return data
def testRestricted2ZStackCommunication(tdir, looper):
"""
Create 2 ZStack and make them send and receive messages.
Both stacks allow communication only when keys are shared
:return:
"""
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
betaP = Printer(names[1])
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=betaP.print,
restricted=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
alpha.send({'greetings': 'hi'}, beta.name)
beta.send({'greetings': 'hello'}, alpha.name)
looper.run(eventually(chkPrinted, alphaP, {'greetings': 'hello'}))
looper.run(eventually(chkPrinted, betaP, {'greetings': 'hi'}))
def registry():
return {
'Alpha': genHa(),
'Beta': genHa(),
'Gamma': genHa(),
'Delta': genHa()
}
def testManyMessages(tdir, looper, set_info_log_level):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
betaMsgHandler = CounterMsgsHandler()
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=betaMsgHandler.handler,
restricted=True)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
looper.runFor(1)
msgNum = 100000
msgSender = MessageSender(msgNum, alpha, beta.name)
looper.add(msgSender)
def checkAllReceived():
assert msgSender.sentMsgCount == msgNum
assert betaMsgHandler.receivedMsgCount == msgNum
looper.run(eventually(checkAllReceived, retryWait=1, timeout=60))
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
data = {'txns': [], 'seeds': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = SimpleSigner(
seed=data['seeds'][steward_name].encode()).identifier
data['txns'].append({
TXN_TYPE: NYM,
ROLE: STEWARD,
ALIAS: steward_name,
TARGET_NYM: s_idr
})
data['txns'].append({
TXN_TYPE: NODE,
f.IDENTIFIER.nm: s_idr,
TARGET_NYM: n_idr,
DATA: {
ALIAS: node_name,
SERVICES: [VALIDATOR],
NODE_IP: '127.0.0.1',
NODE_PORT: genHa()[1],
CLIENT_IP: '127.0.0.1',
CLIENT_PORT: genHa()[1]
}
})
# Below is some static data that is needed for some CLI tests
more_data = {'txns': [
{"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "4AdS22kC7xzb4bcqg9JATuCfAMNcQYcZa1u5eWzs6cSJ",
"type": "1",
"alias": "Alice"},
{"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "46Kq4hASUdvUbwR7s7Pie3x8f4HRB3NLay7Z9jh9eZsB",
"type": "1",
"alias": "Jason"},
{"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "3wpYnGqceZ8DzN3guiTd9rrYkWTwTHCChBSuo6cvkXTG",
"type": "1",
"alias": "John"},
{"identifier": "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC",
"dest": "4Yk9HoDSfJv9QcmJbLcXdWVgS7nfvdUqiVcvbSu8VBru",
"type": "1",
"alias": "Les"}
], 'seeds': {
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}}
data['txns'].extend(more_data['txns'])
data['seeds'].update(more_data['seeds'])
return data
def poolTxnData(nodeAndClientInfoFilePath):
with open(nodeAndClientInfoFilePath) as f:
data = json.loads(f.read().strip())
for txn in data["txns"]:
if txn[TXN_TYPE] == NODE:
txn[DATA][NODE_PORT] = genHa()[1]
txn[DATA][CLIENT_PORT] = genHa()[1]
return data
def poolTxnData(request):
nodeCount = getValueFromModule(request, "nodeCount", 4)
nodes_with_bls = getValueFromModule(request, "nodes_wth_bls", nodeCount)
data = {'txns': [], 'seeds': {}, 'nodesWithBls': {}}
for i, node_name in zip(range(1, nodeCount + 1), genNodeNames(nodeCount)):
data['seeds'][node_name] = node_name + '0' * (32 - len(node_name))
steward_name = 'Steward' + str(i)
data['seeds'][steward_name] = steward_name + \
'0' * (32 - len(steward_name))
n_idr = SimpleSigner(seed=data['seeds'][node_name].encode()).identifier
s_idr = DidSigner(seed=data['seeds'][steward_name].encode())
data['txns'].append({
TXN_TYPE: NYM,
ROLE: STEWARD,
ALIAS: steward_name,
TARGET_NYM: s_idr.identifier,
VERKEY: s_idr.verkey,
})
node_txn = {
TXN_TYPE: NODE,
f.IDENTIFIER.nm: s_idr.identifier,
TARGET_NYM: n_idr,
DATA: {
ALIAS: node_name,
SERVICES: [VALIDATOR],
NODE_IP: '127.0.0.1',
NODE_PORT: genHa()[1],
CLIENT_IP: '127.0.0.1',
CLIENT_PORT: genHa()[1],
}
}
if i <= nodes_with_bls:
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][node_name])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][node_name] = True
data['txns'].append(node_txn)
more_data_seeds = \
{
"Alice": "99999999999999999999999999999999",
"Jason": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"John": "dddddddddddddddddddddddddddddddd",
"Les": "ffffffffffffffffffffffffffffffff"
}
more_data_users = []
for more_name, more_seed in more_data_seeds.items():
signer = DidSigner(seed=more_seed.encode())
more_data_users.append({TXN_TYPE: NYM, ALIAS: more_name, TARGET_NYM: signer.identifier, VERKEY: signer.verkey,
f.IDENTIFIER.nm: "5rArie7XKukPCaEwq5XGQJnM9Fc5aZE3M9HAPVfMU2xC"})
data['txns'].extend(more_data_users)
data['seeds'].update(more_data_seeds)
return data
def testSimpleZStacksMsgs(tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
names = ['Alpha', 'Beta']
aseed = randomSeed()
bseed = randomSeed()
size = 100000
msg = json.dumps({'random': randomSeed(size).decode()}).encode()
def aHandler(m):
str_m = "{}".format(m)
print('{} printing... {}'.format(names[0], str_m[:100]))
d, _ = m
print('Message size is {}'.format(len(d['random'])))
assert len(d['random']) == size
def bHandler(m):
print(beta.msgHandler)
a = m[1]
try:
beta.listener.send_multipart([a, msg], flags=zmq.NOBLOCK)
except zmq.Again:
return False
str_m = "{}".format(m)
print('{} printing... {}'.format(names[1], str_m[:100]))
stackParams = {
"name": names[0],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
alpha = SimpleZStack(stackParams, aHandler, aseed, False)
stackParams = {
"name": names[1],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
beta = SimpleZStack(stackParams, bHandler, bseed, True)
amotor = SMotor(alpha)
looper.add(amotor)
bmotor = SMotor(beta)
looper.add(bmotor)
alpha.connect(name=beta.name,
ha=beta.ha,
verKeyRaw=beta.verKeyRaw,
publicKeyRaw=beta.publicKeyRaw)
looper.runFor(0.25)
alpha.send({'greetings': 'hi'}, beta.name)
looper.runFor(1)
def testSimpleZStacksMsgs(tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
names = ['Alpha', 'Beta']
aseed = randomSeed()
bseed = randomSeed()
size = 100000
msg = json.dumps({'random': randomSeed(size).decode()}).encode()
def aHandler(m):
str_m = "{}".format(m)
print('{} printing... {}'.format(names[0], str_m[:100]))
d, _ = m
print('Message size is {}'.format(len(d['random'])))
assert len(d['random']) == size
def bHandler(m):
print(beta.msgHandler)
a = m[1]
try:
beta.listener.send_multipart([a, msg],
flags=zmq.NOBLOCK)
except zmq.Again:
return False
str_m = "{}".format(m)
print('{} printing... {}'.format(names[1], str_m[:100]))
stackParams = {
"name": names[0],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
alpha = SimpleZStack(stackParams, aHandler, aseed, False)
stackParams = {
"name": names[1],
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
beta = SimpleZStack(stackParams, bHandler, bseed, True)
amotor = SMotor(alpha)
looper.add(amotor)
bmotor = SMotor(beta)
looper.add(bmotor)
alpha.connect(name=beta.name, ha=beta.ha,
verKeyRaw=beta.verKeyRaw, publicKeyRaw=beta.publicKeyRaw)
looper.runFor(0.25)
alpha.send({'greetings': 'hi'}, beta.name)
looper.runFor(1)
def testChangeNodeHaBack(looper, txnPoolNodeSet, tdir, tconf,
steward1, stewardWallet, nodeThetaAdded):
"""
The case:
The Node HA is updated with some HA (let's name it 'correct' HA).
Then the Steward makes a mistake and sends the NODE txn with other HA
('wrong' HA). The Steward replaces back 'wrong' HA by 'correct' HA sending
yet another one NODE txn.
"""
steward, stewardWallet, theta = nodeThetaAdded
clientHa = theta.cliNodeReg['ThetaC'] # use the same client HA
# do all exercises without the Node
theta.stop()
looper.removeProdable(name=theta.name)
# step 1: set 'correct' HA
correctNodeHa = genHa(1)
op = {
ALIAS: theta.name,
NODE_IP: correctNodeHa.host,
NODE_PORT: correctNodeHa.port,
CLIENT_IP: clientHa.host,
CLIENT_PORT: clientHa.port,
}
updateNodeData(looper, steward, stewardWallet, theta,
op)
# step 2: set 'wrong' HA
wrongNodeHa = genHa(1)
op.update({NODE_IP: wrongNodeHa.host, NODE_PORT: wrongNodeHa.port})
updateNodeData(looper, steward, stewardWallet, theta,
op)
# step 3: set 'correct' HA back
op.update({NODE_IP: correctNodeHa.host, NODE_PORT: correctNodeHa.port})
updateNodeData(looper, steward, stewardWallet, theta,
op)
# In order to save the time the pool connection is not maintaining
# during the steps, only the final result is checked.
config_helper = PNodeConfigHelper(theta.name, tconf, chroot=tdir)
restartedNode = TestNode(theta.name,
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, ha=correctNodeHa, cliha=clientHa)
looper.add(restartedNode)
txnPoolNodeSet[-1] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet))
# check Theta HA
for n in txnPoolNodeSet:
assert n.nodeReg['Theta'] == correctNodeHa
def testConsecutiveAddSameNodeWithNonAliasChange(be, do, newStewardCli,
newNodeVals, newNodeAdded):
be(newStewardCli)
nodeIp, nodePort = genHa()
clientIp, clientPort = genHa()
newNodeVals['newNodeData'][NODE_IP] = nodeIp
newNodeVals['newNodeData'][NODE_PORT] = nodePort
newNodeVals['newNodeData'][CLIENT_IP] = nodeIp
newNodeVals['newNodeData'][CLIENT_PORT] = clientPort
doSendNodeCmd(do, newNodeVals)
exitFromCli(do)
def testConsecutiveAddSameNodeWithNonAliasChange(be, do, newStewardCli,
newNodeAdded):
be(newStewardCli)
nodeIp, nodePort = genHa()
clientIp, clientPort = genHa()
vals['newNodeData'][NODE_IP] = nodeIp
vals['newNodeData'][NODE_PORT] = nodePort
vals['newNodeData'][CLIENT_IP] = nodeIp
vals['newNodeData'][CLIENT_PORT] = clientPort
doNodeCmd(do, nodeData=vals)
exitFromCli(do)
def testZStackRecvHugeDataOverLimit(set_info_log_level, tdir, looper, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
# we use json serializer now, so final form will be {'k':'vvv...vvv'}
# so here we try to prepare exactly tconf.MSG_LEN_LIMIT + 1 bytes after serialization
msg = {'k': 'v' * (tconf.MSG_LEN_LIMIT - len("{'k':''}") + 1)}
betaHandlers = [False, False]
def recvHandlerAlpha(wrpMsg):
pass
def recvHandlerBeta(wrpMsg):
rmsg, frm = wrpMsg
betaHandlers[0] = True
assert frm is not None
assert rmsg is not None
def rejectHandlerBeta(reason, frm):
betaHandlers[1] = True
assert 'exceeded allowed limit of {}'.format(
tconf.MSG_LEN_LIMIT) in reason
assert frm == 'Alpha'
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=recvHandlerAlpha,
restricted=True,
config=adict(**tconf.__dict__),
msgRejectHandler=None)
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=recvHandlerBeta,
restricted=True,
config=adict(**tconf.__dict__),
msgRejectHandler=rejectHandlerBeta)
bytemsg = alpha.serializeMsg(msg)
assert len(bytemsg) == (tconf.MSG_LEN_LIMIT + 1)
prepStacks(looper, *(alpha, beta), connect=True, useKeys=True)
stat = alpha._remotes['Beta'].socket.send(bytemsg, copy=False, track=True)
assert stat
looper.runFor(5)
assert betaHandlers[0] is False
assert betaHandlers[1] is True
def testChangeNodeHaBack(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_node_theta_added,
tconf, tdir):
"""
The case:
The Node HA is updated with some HA (let's name it 'correct' HA).
Then the Steward makes a mistake and sends the NODE txn with other HA
('wrong' HA). The Steward replaces back 'wrong' HA by 'correct' HA sending
yet another one NODE txn.
"""
new_steward_wallet, new_node = sdk_node_theta_added
client_ha = new_node.cliNodeReg['ThetaC'] # use the same client HA
# do all exercises without the Node
new_node.stop()
looper.removeProdable(name=new_node.name)
# step 1: set 'correct' HA
correct_node_ha = genHa(1)
node_dest = hexToFriendly(new_node.nodestack.verhex)
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name,
correct_node_ha.host, correct_node_ha.port,
client_ha.host, client_ha.port)
# step 2: set 'wrong' HA
wrong_node_ha = genHa(1)
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name,
wrong_node_ha.host, wrong_node_ha.port,
client_ha.host, client_ha.port)
# step 3: set 'correct' HA back
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name,
correct_node_ha.host, correct_node_ha.port,
client_ha.host, client_ha.port)
# In order to save the time the pool connection is not maintaining
# during the steps, only the final result is checked.
config_helper = PNodeConfigHelper(new_node.name, tconf, chroot=tdir)
restartedNode = TestNode(new_node.name,
config_helper=config_helper,
config=tconf, ha=correct_node_ha, cliha=client_ha)
looper.add(restartedNode)
txnPoolNodeSet[-1] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet))
# check Theta HA
for n in txnPoolNodeSet:
assert n.nodeReg['Theta'] == correct_node_ha
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM:
stewardSigner.verkey,
ROLE:
STEWARD,
TXN_TYPE:
NYM,
ALIAS:
poolId + "Steward" + str(index),
TXN_ID:
sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
node_txn = {
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID:
sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
}
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][n] = True
data["txns"].append(node_txn)
return data
def test_stashing_unknown_remote_msgs(looper, tdir, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=None,
restricted=False)
beta_msg_handler = CounterMsgsHandler()
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=beta_msg_handler.handler,
restricted=False)
prepStacks(looper, alpha, beta, connect=False)
assert not alpha.hasRemote(beta.name)
assert not alpha.isConnectedTo(beta.name)
assert not beta.hasRemote(alpha.name)
assert not beta.isConnectedTo(alpha.name)
alpha.connect(name=beta.name,
ha=beta.ha,
verKeyRaw=beta.verKeyRaw,
publicKeyRaw=beta.publicKeyRaw)
alpha.getRemote(beta.name, beta.ha).setConnected()
assert alpha.hasRemote(beta.name)
assert alpha.isConnectedTo(beta.name)
assert not beta.hasRemote(alpha.name)
assert not beta.isConnectedTo(alpha.name)
def check_unknown_remote_msg():
assert len(alpha._stashed_to_disconnected) == 0
assert len(beta._stashed_unknown_remote_msgs) == len(sent_msgs)
for index, item in enumerate(sent_msgs):
assert item == beta._stashed_unknown_remote_msgs[index][0]
assert alpha.remotes[
'Beta'].socket.IDENTITY == beta._stashed_unknown_remote_msgs[
index][1]
sent_msgs = deque(maxlen=tconf.ZMQ_STASH_UNKNOWN_REMOTE_MSGS_QUEUE_SIZE)
msg = 'message num: {}'
for i in range(5):
_msg = msg.format(i)
alpha.send(_msg)
sent_msgs.append(_msg)
looper.run(
eventually(check_unknown_remote_msg, retryWait=1, timeout=60))
def test_queue_size_limit_set(tdir, tconf):
stack = ZStack("Alpha", ha=genHa(), basedirpath=tdir, msgHandler=None,
restricted=False, seed=randomSeed(), config=tconf)
stack.start()
assert stack.listener.get_hwm() == 0
stack.stop()
queue_size = 100
stack = ZStack("Alpha", ha=genHa(), basedirpath=tdir, msgHandler=None,
restricted=False, seed=randomSeed(), config=tconf, queue_size=queue_size)
stack.start()
assert stack.listener.get_hwm() == queue_size
stack.stop()
def testRaetPreSharedKeysNonPromiscous(tdir):
alphaSigner = NaclSigner()
betaSigner = NaclSigner()
alphaPrivateer = Privateer()
betaPrivateer = Privateer()
logger.debug("Alpha's verkey {}".format(alphaSigner.verhex))
logger.debug("Beta's verkey {}".format(betaSigner.verhex))
alpha = RoadStack(name='alpha',
ha=genHa(),
sigkey=alphaSigner.keyhex,
prikey=alphaPrivateer.keyhex,
auto=AutoMode.never,
basedirpath=tdir)
beta = RoadStack(name='beta',
ha=genHa(),
sigkey=betaSigner.keyhex,
prikey=betaPrivateer.keyhex,
main=True,
auto=AutoMode.never,
basedirpath=tdir)
alpha.keep.dumpRemoteRoleData({
"acceptance": Acceptance.accepted.value,
"verhex": betaSigner.verhex,
"pubhex": betaPrivateer.pubhex
}, "beta")
beta.keep.dumpRemoteRoleData({
"acceptance": Acceptance.accepted.value,
"verhex": alphaSigner.verhex,
"pubhex": alphaPrivateer.pubhex
}, "alpha")
try:
betaRemote = RemoteEstate(stack=alpha, ha=beta.ha)
alpha.addRemote(betaRemote)
alpha.allow(uid=betaRemote.uid, cascade=True)
handshake(alpha, beta)
sendMsgs(alpha, beta, betaRemote)
finally:
cleanup(alpha, beta)
def nodeReg():
return {
'Alpha': NodeDetail(genHa(1), "AlphaC", genHa(1)),
'Beta': NodeDetail(genHa(1), "BetaC", genHa(1)),
'Gamma': NodeDetail(genHa(1), "GammaC", genHa(1)),
'Delta': NodeDetail(genHa(1), "DeltaC", genHa(1))
}
def testChangeNodeHaBack(looper, txnPoolNodeSet, sdk_pool_handle,
sdk_node_theta_added, tconf, tdir):
"""
The case:
The Node HA is updated with some HA (let's name it 'correct' HA).
Then the Steward makes a mistake and sends the NODE txn with other HA
('wrong' HA). The Steward replaces back 'wrong' HA by 'correct' HA sending
yet another one NODE txn.
"""
new_steward_wallet, new_node = sdk_node_theta_added
client_ha = new_node.cliNodeReg['ThetaC'] # use the same client HA
# do all exercises without the Node
new_node.stop()
looper.removeProdable(name=new_node.name)
# step 1: set 'correct' HA
correct_node_ha = genHa(1)
node_dest = hexToFriendly(new_node.nodestack.verhex)
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name, correct_node_ha.host,
correct_node_ha.port, client_ha.host, client_ha.port)
# step 2: set 'wrong' HA
wrong_node_ha = genHa(1)
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name, wrong_node_ha.host,
wrong_node_ha.port, client_ha.host, client_ha.port)
# step 3: set 'correct' HA back
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name, correct_node_ha.host,
correct_node_ha.port, client_ha.host, client_ha.port)
# In order to save the time the pool connection is not maintaining
# during the steps, only the final result is checked.
config_helper = PNodeConfigHelper(new_node.name, tconf, chroot=tdir)
restartedNode = TestNode(new_node.name,
config_helper=config_helper,
config=tconf,
ha=correct_node_ha,
cliha=client_ha)
looper.add(restartedNode)
txnPoolNodeSet[-1] = restartedNode
looper.run(checkNodesConnected(txnPoolNodeSet))
# check Theta HA
for n in txnPoolNodeSet:
assert n.nodeReg['Theta'] == correct_node_ha
def _(wallet, basedir=None):
basedir = basedir or tdirWithPoolTxns
_, port = genHa()
_, clientPort = genHa()
client = TestClient(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedir)
agent = WalletedAgent(name=wallet.name,
basedirpath=basedir,
client=client,
wallet=wallet,
port=port)
return agent
def _(wallet, basedir=None):
basedir = basedir or tdirWithPoolTxns
_, port = genHa()
_, clientPort = genHa()
client = TestClient(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedir)
agent = TestWalletedAgent(name=wallet.name,
basedirpath=basedir,
client=client,
wallet=wallet,
port=port)
return agent
def prepare_new_node_data(tconf, tdir, newNodeName, configClass=PNodeConfigHelper):
sigseed = randomString(32).encode()
(nodeIp, nodePort), (clientIp, clientPort) = genHa(2)
config_helper = configClass(newNodeName, tconf, chroot=tdir)
pubkey, verkey, bls_key, key_proof = initNodeKeysForBothStacks(newNodeName, config_helper.keys_dir,
sigseed, override=True)
return sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof
def put_load():
port = genHa()[1]
ha = HA('0.0.0.0', port)
name = "hello"
wallet = Wallet(name)
wallet.addIdentifier(
signer=DidSigner(seed=b'000000000000000000000000Steward1'))
client = Client(name, ha=ha)
with Looper(debug=getConfig().LOOPER_DEBUG) as looper:
looper.add(client)
print('Will send {} reqs in all'.format(numReqs))
requests = sendRandomRequests(wallet, client, numReqs)
start = perf_counter()
for i in range(0, numReqs, numReqs // splits):
print('Will wait for {} now'.format(numReqs // splits))
s = perf_counter()
reqs = requests[i:i + numReqs // splits + 1]
waitForSufficientRepliesForRequests(looper, client, requests=reqs,
customTimeoutPerReq=100,
override_timeout_limit=True)
print('>>> Got replies for {} requests << in {}'.
format(numReqs // splits, perf_counter() - s))
end = perf_counter()
print('>>>Total {} in {}<<<'.format(numReqs, end - start))
exit(0)
def prepare_new_node_data(tconf, tdir, newNodeName, configClass=PNodeConfigHelper):
sigseed = randomString(32).encode()
(nodeIp, nodePort), (clientIp, clientPort) = genHa(2)
config_helper = configClass(newNodeName, tconf, chroot=tdir)
pubkey, verkey, bls_key, key_proof = initNodeKeysForBothStacks(newNodeName, config_helper.keys_dir,
sigseed, override=True)
return sigseed, verkey, bls_key, nodeIp, nodePort, clientIp, clientPort, key_proof
def nodeRegsForCLI(nodeNames):
nodeNames = ['Alpha', 'Beta', 'Gamma', 'Delta']
has = [genHa(2) for _ in nodeNames]
nodeNamesC = [n + 'C' for n in nodeNames]
nodeReg = OrderedDict((n, has[i][0]) for i, n in enumerate(nodeNames))
cliNodeReg = OrderedDict((n, has[i][1]) for i, n in enumerate(nodeNamesC))
return adict(nodeReg=nodeReg, cliNodeReg=cliNodeReg)
def changeHA(looper, config, nodeName, nodeSeed, newNodeHA,
stewardName, stewardsSeed, newClientHA=None):
if not newClientHA:
newClientHA = HA(newNodeHA.host, newNodeHA.port + 1)
# prepare steward wallet
stewardSigner = SimpleSigner(seed=stewardsSeed)
stewardWallet = Wallet(stewardName)
stewardWallet.addIdentifier(signer=stewardSigner)
# prepare client to submit change ha request
_, randomClientPort = genHa()
client = Client(stewardName,
ha=('0.0.0.0', randomClientPort), config=config)
looper.add(client)
timeout = waits.expectedClientToPoolConnectionTimeout(4)
looper.run(eventually(__checkClientConnected, client,
retryWait=1, timeout=timeout))
nodeVerKey = SimpleSigner(seed=nodeSeed).verkey
# send request
req = submitNodeIpChange(client, stewardWallet, nodeName, nodeVerKey,
newNodeHA, newClientHA)
return client, req
def test_get_msgs_from_rxMsgs_queue(create_node_and_not_start, looper):
node = create_node_and_not_start
node.view_changer = create_view_changer(node)
node.view_changer.pre_vc_strategy = VCStartMsgStrategy(view_changer, node)
node.view_changer.view_no = 0
"""pre_view_change stage"""
node.view_changer.start_view_change(1)
assert node.view_changer.view_no == 0
prepare = Prepare(
0,
0,
1,
get_utc_epoch(),
'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
'7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ')
inst_change = InstanceChange(1, 25)
m = node.nodeInBox.popleft()
assert isinstance(m[0], ViewChangeStartMessage)
node.nodestack.addRemote('someNode', genHa(), b'1DYuELN<SHbv1?NJ=][4De%^Hge887B0I!s<YGdD', 'pubkey')
node.nodestack.rxMsgs.append((json.dumps(prepare._asdict()), 'pubkey'))
node.nodestack.rxMsgs.append((json.dumps(inst_change._asdict()), 'pubkey'))
node.msgHasAcceptableViewNo = lambda *args, **kwargs: True
"""While processing ViewChangeStartMessage from nodeInBox queue, should be:
- move msgs from rxMsgs queue to nodeInBox queue
- process all 3PC msgs (for Prepare msg it should be moved to inBox queue of master_replica)
- add ViewChangeContinue msg into master_replica's inBox queue
- all not 3PC msgs will be stashed in strategy queue"""
looper.run(node.process_one_node_message(m))
m = node.master_replica.inBox.popleft()
assert isinstance(m[0], Prepare)
m = node.master_replica.inBox.popleft()
assert isinstance(m, ViewChangeContinueMessage)
m = node.view_changer.pre_vc_strategy.stashedNodeInBox.popleft()
assert isinstance(m[0], InstanceChange)
def test_get_msgs_from_rxMsgs_queue(create_node_and_not_start, looper):
node = create_node_and_not_start
node.view_changer = ViewChanger(node)
node.view_changer.view_no = 0
"""pre_view_change stage"""
node.view_changer.startViewChange(1)
assert node.view_changer.view_no == 0
prepare = Prepare(
0,
0,
1,
get_utc_epoch(),
'f99937241d4c891c08e92a3cc25966607315ca66b51827b170d492962d58a9be',
'CZecK1m7VYjSNCC7pGHj938DSW2tfbqoJp1bMJEtFqvG',
'7WrAMboPTcMaQCU1raoj28vnhu2bPMMd2Lr9tEcsXeCJ')
inst_change = InstanceChange(1, 25)
m = node.nodeInBox.popleft()
assert isinstance(m[0], ViewChangeStartMessage)
node.nodestack.addRemote('someNode', genHa(), b'1DYuELN<SHbv1?NJ=][4De%^Hge887B0I!s<YGdD', 'pubkey')
node.nodestack.rxMsgs.append((json.dumps(prepare._asdict()), 'pubkey'))
node.nodestack.rxMsgs.append((json.dumps(inst_change._asdict()), 'pubkey'))
node.msgHasAcceptableViewNo = lambda *args, **kwargs: True
"""While processing ViewChangeStartMessage from nodeInBox queue, should be:
- move msgs from rxMsgs queue to nodeInBox queue
- process all 3PC msgs (for Prepare msg it should be moved to inBox queue of master_replica)
- add ViewChangeContinue msg into master_replica's inBox queue
- all not 3PC msgs will be stashed in strategy queue"""
looper.run(node.process_one_node_message(m))
m = node.master_replica.inBox.popleft()
assert isinstance(m[0], Prepare)
m = node.master_replica.inBox.popleft()
assert isinstance(m, ViewChangeContinueMessage)
m = node.view_changer.pre_vc_strategy.stashedNodeInBox.popleft()
assert isinstance(m[0], InstanceChange)
def sendAddNewNode(tdir, newNodeName, stewardClient, stewardWallet,
transformOpFunc=None):
sigseed = randomString(32).encode()
nodeSigner = SimpleSigner(seed=sigseed)
(nodeIp, nodePort), (clientIp, clientPort) = genHa(2)
_, verkey, bls_key = initNodeKeysForBothStacks(newNodeName, tdir, sigseed, override=True)
op = {
TXN_TYPE: NODE,
TARGET_NYM: nodeSigner.identifier,
DATA: {
NODE_IP: nodeIp,
NODE_PORT: nodePort,
CLIENT_IP: clientIp,
CLIENT_PORT: clientPort,
ALIAS: newNodeName,
SERVICES: [VALIDATOR, ],
BLS_KEY: bls_key
}
}
if transformOpFunc is not None:
transformOpFunc(op)
req = stewardWallet.signOp(op)
stewardClient.submitReqs(req)
return req, \
op[DATA].get(NODE_IP), op[DATA].get(NODE_PORT), \
op[DATA].get(CLIENT_IP), op[DATA].get(CLIENT_PORT), \
sigseed
def load():
port = genHa()[1]
ha = HA('0.0.0.0', port)
name = "hello"
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(
seed=b'000000000000000000000000Steward1'))
client = Client(name, ha=ha)
with Looper(debug=getConfig().LOOPER_DEBUG) as looper:
looper.add(client)
print('Will send {} reqs in all'.format(numReqs))
requests = sendRandomRequests(wallet, client, numReqs)
start = perf_counter()
for i in range(0, numReqs, numReqs // splits):
print('Will wait for {} now'.format(numReqs // splits))
s = perf_counter()
reqs = requests[i:i + numReqs // splits + 1]
waitForSufficientRepliesForRequests(looper,
client,
requests=reqs,
fVal=2,
customTimeoutPerReq=3)
print('>>> Got replies for {} requests << in {}'.format(
numReqs // splits,
perf_counter() - s))
end = perf_counter()
print('>>>{}<<<'.format(end - start))
exit(0)
def testChangeHaPersistsPostNodesRestart(looper, txnPoolNodeSet,
tdir, tconf,
sdk_pool_handle,
sdk_wallet_client,
sdk_wallet_steward):
new_steward_wallet, new_node = \
sdk_add_new_steward_and_node(looper,
sdk_pool_handle,
sdk_wallet_steward,
'AnotherSteward' + randomString(4),
'AnotherNode' + randomString(4),
tdir,
tconf)
txnPoolNodeSet.append(new_node)
looper.run(checkNodesConnected(txnPoolNodeSet))
sdk_pool_refresh(looper, sdk_pool_handle)
node_new_ha, client_new_ha = genHa(2)
logger.debug("{} changing HAs to {} {}".format(new_node, node_new_ha,
client_new_ha))
# Making the change HA txn an confirming its succeeded
node_dest = hexToFriendly(new_node.nodestack.verhex)
sdk_send_update_node(looper, new_steward_wallet, sdk_pool_handle,
node_dest, new_node.name,
node_new_ha.host, node_new_ha.port,
client_new_ha.host, client_new_ha.port)
# Stopping existing nodes
for node in txnPoolNodeSet:
node.stop()
looper.removeProdable(node)
# Starting nodes again by creating `Node` objects since that simulates
# what happens when starting the node with script
restartedNodes = []
for node in txnPoolNodeSet[:-1]:
config_helper = PNodeConfigHelper(node.name, tconf, chroot=tdir)
restartedNode = TestNode(node.name,
config_helper=config_helper,
config=tconf, ha=node.nodestack.ha,
cliha=node.clientstack.ha)
looper.add(restartedNode)
restartedNodes.append(restartedNode)
# Starting the node whose HA was changed
config_helper = PNodeConfigHelper(new_node.name, tconf, chroot=tdir)
node = TestNode(new_node.name,
config_helper=config_helper,
config=tconf,
ha=node_new_ha, cliha=client_new_ha)
looper.add(node)
restartedNodes.append(node)
looper.run(checkNodesConnected(restartedNodes))
waitNodeDataEquality(looper, node, *restartedNodes[:-1])
sdk_pool_refresh(looper, sdk_pool_handle)
sdk_ensure_pool_functional(looper, restartedNodes, sdk_wallet_client, sdk_pool_handle)
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append({
TARGET_NYM: stewardSigner.verkey,
ROLE: STEWARD, TXN_TYPE: NYM,
ALIAS: poolId + "Steward" + str(index),
TXN_ID: sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()
})
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
node_txn = {
TARGET_NYM: nodeSigner.verkey,
TXN_TYPE: NODE,
f.IDENTIFIER.nm: stewardSigner.verkey,
DATA: {
CLIENT_IP: "127.0.0.1",
ALIAS: newNodeAlias,
NODE_IP: "127.0.0.1",
NODE_PORT: genHa()[1],
CLIENT_PORT: genHa()[1],
SERVICES: [VALIDATOR],
},
TXN_ID: sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
}
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
node_txn[DATA][BLS_KEY] = bls_key
data['nodesWithBls'][n] = True
data["txns"].append(node_txn)
return data
def genNodeReg(count=None, names=None) -> Dict[str, NodeDetail]:
"""
:param count: number of nodes, mutually exclusive with names
:param names: iterable with names of nodes, mutually exclusive with count
:return: dictionary of name: (node stack HA, client stack name, client stack HA)
"""
if names is None:
names = genNodeNames(count)
nodeReg = OrderedDict(
(n, NodeDetail(genHa(), n + CLIENT_STACK_SUFFIX, genHa())) for n in
names)
def extractCliNodeReg(self):
return OrderedDict((n.cliname, n.cliha) for n in self.values())
nodeReg.extractCliNodeReg = types.MethodType(extractCliNodeReg, nodeReg)
return nodeReg
def getPoolTxnData(poolId, newPoolTxnNodeNames):
data = {}
data["seeds"] = {}
data["txns"] = []
data['nodesWithBls'] = {}
for index, n in enumerate(newPoolTxnNodeNames, start=1):
newStewardAlias = poolId + "Steward" + str(index)
stewardSeed = (newStewardAlias + "0" *
(32 - len(newStewardAlias))).encode()
data["seeds"][newStewardAlias] = stewardSeed
stewardSigner = SimpleSigner(seed=stewardSeed)
data["txns"].append(
Member.nym_txn(nym=stewardSigner.identifier,
verkey=stewardSigner.verkey,
role=STEWARD,
name=poolId + "Steward" + str(index),
seq_no=index,
txn_id=sha256("{}".format(stewardSigner.verkey).encode()).hexdigest()))
newNodeAlias = n
nodeSeed = (newNodeAlias + "0" * (32 - len(newNodeAlias))).encode()
data["seeds"][newNodeAlias] = nodeSeed
nodeSigner = SimpleSigner(seed=nodeSeed)
_, bls_key = create_default_bls_crypto_factory().generate_bls_keys(
seed=data['seeds'][n])
data['nodesWithBls'][n] = True
node_txn = Steward.node_txn(
steward_nym=stewardSigner.verkey,
node_name=newNodeAlias,
nym=nodeSigner.verkey,
ip="127.0.0.1",
node_port=genHa()[1],
client_port=genHa()[1],
client_ip="127.0.0.1",
blskey=bls_key,
services=[VALIDATOR],
txn_id=sha256("{}".format(nodeSigner.verkey).encode()).hexdigest()
)
data["txns"].append(node_txn)
return data
def changeNodeHa(looper, txnPoolNodeSet,
tconf, shouldBePrimary, tdir,
sdk_pool_handle, sdk_wallet_stewards,
sdk_wallet_client):
# 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))
electionTimeout = waits.expectedPoolElectionTimeout(
nodeCount=len(txnPoolNodeSet),
numOfReelections=3)
ensureElectionsDone(looper,
txnPoolNodeSet,
retryWait=1,
customTimeout=electionTimeout)
sdk_pool_refresh(looper, sdk_pool_handle)
sdk_send_random_and_check(looper, txnPoolNodeSet,
sdk_pool_handle,
sdk_wallet_client,
8)
def createClientAndWalletWithSeed(name, seed, ha=None):
if isinstance(seed, str):
seed = seed.encode()
if not ha:
port = genHa()[1]
ha = HA('0.0.0.0', port)
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(seed=seed))
client = Client(name, ha=ha)
return client, wallet
def testZStackRecvHugeDataOverLimit(set_info_log_level, tdir, looper, tconf):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
# we use json serializer now, so final form will be {'k':'vvv...vvv'}
# so here we try to prepare exactly tconf.MSG_LEN_LIMIT + 1 bytes after serialization
msg = {'k': 'v' * (tconf.MSG_LEN_LIMIT - len("{'k':''}") + 1)}
betaHandlers = [False, False]
def recvHandlerAlpha(wrpMsg):
pass
def recvHandlerBeta(wrpMsg):
rmsg, frm = wrpMsg
betaHandlers[0] = True
assert frm is not None
assert rmsg is not None
def rejectHandlerBeta(reason, frm):
betaHandlers[1] = True
assert 'exceeded allowed limit of {}'.format(
tconf.MSG_LEN_LIMIT) in reason
assert frm == 'Alpha'
alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerAlpha, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=None)
beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=recvHandlerBeta, restricted=True,
config=adict(**tconf.__dict__), msgRejectHandler=rejectHandlerBeta)
bytemsg = alpha.serializeMsg(msg)
assert len(bytemsg) == (tconf.MSG_LEN_LIMIT + 1)
prepStacks(looper, *(alpha, beta), connect=True, useKeys=True)
stat = alpha._remotes['Beta'].socket.send(bytemsg, copy=False, track=True)
assert stat
looper.runFor(5)
assert betaHandlers[0] is False
assert betaHandlers[1] is True
def newNodeVals():
newNodeSeed = randomSeed()
nodeIp, nodePort = genHa()
clientIp, clientPort = genHa()
newNodeData = {
NODE_IP: nodeIp,
NODE_PORT: nodePort,
CLIENT_IP: clientIp,
CLIENT_PORT: clientPort,
ALIAS: randomString(6),
SERVICES: [VALIDATOR]
}
return {
'newNodeSeed': newNodeSeed.decode(),
'newNodeIdr': SimpleSigner(seed=newNodeSeed).identifier,
'newNodeData': newNodeData
}
def testUnrestricted2ZStackCommunication(tdir, looper, tconf):
"""
Create 2 ZStack and make them send and receive messages.
Both stacks allow communication even when keys are not shared
:return:
"""
names = ['Alpha', 'Beta']
alphaP = Printer(names[0])
betaP = Printer(names[1])
alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=alphaP.print,
restricted=False, seed=randomSeed(), config=tconf)
beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=betaP.print,
restricted=False, seed=randomSeed(), config=tconf)
prepStacks(looper, alpha, beta, connect=True, useKeys=True)
alpha.send({'greetings': 'hi'}, beta.name)
beta.send({'greetings': 'hello'}, alpha.name)
looper.run(eventually(chkPrinted, alphaP, {'greetings': 'hello'}))
looper.run(eventually(chkPrinted, betaP, {'greetings': 'hi'}))
def create_client(base_dir_path=None, client_class=Client):
config = getConfig()
if not base_dir_path:
base_dir_path = config.CLI_BASE_DIR
_, clientPort = genHa()
client = client_class(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=base_dir_path)
return client
def createClientAndWalletWithSeed(name, seed, ha=None):
if isinstance(seed, str):
seed = seed.encode()
if not ha:
# if not ha and not isLocalKeepSetup(name, config.baseDir):
port = genHa()[1]
ha = HA('0.0.0.0', port)
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(seed=seed))
client = Client(name, ha=ha)
return client, wallet
def testConsecutiveAddSameNodeWithNodeAndClientPortSame(be, do, newStewardCli,
newNodeVals,
newNodeAdded):
be(newStewardCli)
nodeIp, nodePort = genHa()
newNodeVals['newNodeData'][NODE_IP] = nodeIp
newNodeVals['newNodeData'][NODE_PORT] = nodePort
newNodeVals['newNodeData'][CLIENT_IP] = nodeIp
newNodeVals['newNodeData'][CLIENT_PORT] = nodePort
doSendNodeCmd(do, newNodeVals,
expMsgs=["node and client ha cannot be same"])
exitFromCli(do)
def test_update_ports_and_ips(be, do, newStewardCli,
newNodeVals, newNodeAdded,
nodeValsEmptyData):
'''
Checks that it's possible to update node and client ports and IPs (by owner)
(just alias and ports/IPs are required)
'''
be(newStewardCli)
nodeIp, nodePort = genHa()
clientIp, clientPort = genHa()
node_vals = nodeValsEmptyData
node_vals['newNodeData'][ALIAS] = newNodeVals['newNodeData'][ALIAS]
node_vals['newNodeData'][NODE_IP] = nodeIp
node_vals['newNodeData'][NODE_PORT] = nodePort
node_vals['newNodeData'][CLIENT_IP] = clientIp
node_vals['newNodeData'][CLIENT_PORT] = clientPort
doSendNodeCmd(do, node_vals,
expMsgs=['Node request completed'])
exitFromCli(do)
def create_fake_nodestack(tdir, tconf, registry, name='Node1'):
def msgHandler(msg):
pass
stackParams = {
"name": name,
"ha": genHa(),
"auto": 2,
"basedirpath": tdir
}
stack = nodeStackClass(stackParams, msgHandler, registry, randomString(32), config=tconf)
return stack
def create_stacks(tdir, looper):
names = ['Alpha', 'Beta']
genKeys(tdir, names)
alphaP = Printer(names[0])
alpha = ZStack(names[0],
ha=genHa(),
basedirpath=tdir,
msgHandler=alphaP.print,
restricted=True)
prepStacks(looper, alpha, connect=False)
beta_msg_handler = CounterMsgsHandler()
beta = ZStack(names[1],
ha=genHa(),
basedirpath=tdir,
msgHandler=beta_msg_handler.handler,
restricted=True)
prepStacks(looper, beta, connect=False)
return alpha, beta
def nodeThetaAdded(looper, nodeSet, tdirWithPoolTxns, tconf, steward,
stewardWallet, allPluginsPath, testNodeClass,
testClientClass, tdir):
newStewardName = "testClientSteward" + randomString(3)
newNodeName = "Theta"
newSteward, newStewardWallet = getClientAddedWithRole(nodeSet, tdir,
looper, steward,
stewardWallet,
newStewardName,
role=STEWARD)
sigseed = randomString(32).encode()
nodeSigner = SimpleSigner(seed=sigseed)
(nodeIp, nodePort), (clientIp, clientPort) = genHa(2)
data = {
NODE_IP: nodeIp,
NODE_PORT: nodePort,
CLIENT_IP: clientIp,
CLIENT_PORT: clientPort,
ALIAS: newNodeName,
SERVICES: [VALIDATOR, ]
}
node = Node(nodeSigner.identifier, data, newStewardWallet.defaultId)
newStewardWallet.addNode(node)
reqs = newStewardWallet.preparePending()
req, = newSteward.submitReqs(*reqs)
waitForSufficientRepliesForRequests(looper, newSteward, requests=[req])
def chk():
assert newStewardWallet.getNode(node.id).seqNo is not None
timeout = plenumWaits.expectedTransactionExecutionTime(len(nodeSet))
looper.run(eventually(chk, retryWait=1, timeout=timeout))
initNodeKeysForBothStacks(newNodeName, tdirWithPoolTxns, sigseed, override=True)
newNode = testNodeClass(newNodeName, basedirpath=tdir, config=tconf,
ha=(nodeIp, nodePort), cliha=(clientIp, clientPort),
pluginPaths=allPluginsPath)
nodeSet.append(newNode)
looper.add(newNode)
looper.run(checkNodesConnected(nodeSet))
ensureClientConnectedToNodesAndPoolLedgerSame(looper, steward,
*nodeSet)
ensureClientConnectedToNodesAndPoolLedgerSame(looper, newSteward,
*nodeSet)
return newSteward, newStewardWallet, newNode
def testNodePortCannotBeChangedByAnotherSteward(looper, txnPoolNodeSet,
sdk_wallet_steward,
sdk_pool_handle,
sdk_node_theta_added):
new_steward_wallet, new_node = sdk_node_theta_added
node_new_ha, client_new_ha = genHa(2)
logger.debug("{} changing HAs to {} {}".format(new_node, node_new_ha,
client_new_ha))
node_dest = hexToFriendly(new_node.nodestack.verhex)
with pytest.raises(RequestRejectedException) as e:
sdk_send_update_node(looper, sdk_wallet_steward, sdk_pool_handle,
node_dest, new_node.name,
node_new_ha.host, node_new_ha.port,
client_new_ha.host, client_new_ha.port)
assert 'is not a steward of node' in e._excinfo[1].args[0]
sdk_pool_refresh(looper, sdk_pool_handle)
