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 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 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 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 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 _(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 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 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 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)