def testNodeKeysChanged(looper, txnPoolNodeSet, tdirWithPoolTxns, tconf, steward1, nodeThetaAdded, allPluginsPath=None): newSteward, newStewardWallet, newNode = nodeThetaAdded newNode.stop() looper.removeProdable(name=newNode.name) nodeHa, nodeCHa = HA(*newNode.nodestack.ha), HA(*newNode.clientstack.ha) sigseed = randomString(32).encode() verkey = base58.b58encode(SimpleSigner(seed=sigseed).naclSigner.verraw) changeNodeKeys(looper, newSteward, newStewardWallet, newNode, verkey) initNodeKeysForBothStacks(newNode.name, tdirWithPoolTxns, sigseed, override=True) logger.debug("{} starting with HAs {} {}".format(newNode, nodeHa, nodeCHa)) node = TestNode(newNode.name, basedirpath=tdirWithPoolTxns, config=tconf, ha=nodeHa, cliha=nodeCHa, pluginPaths=allPluginsPath) looper.add(node) # The last element of `txnPoolNodeSet` is the node Theta that was just # stopped txnPoolNodeSet[-1] = node looper.run(checkNodesConnected(stacks=txnPoolNodeSet)) waitNodeDataEquality(looper, node, *txnPoolNodeSet[:-1]) ensureClientConnectedToNodesAndPoolLedgerSame(looper, steward1, *txnPoolNodeSet) ensureClientConnectedToNodesAndPoolLedgerSame(looper, newSteward, *txnPoolNodeSet)
def tdirWithNodeKeepInited(tdir, tconf, node_config_helper_class, poolTxnData, poolTxnNodeNames): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: seed = seeds[nName] use_bls = nName in poolTxnData['nodesWithBls'] config_helper = node_config_helper_class(nName, tconf, chroot=tdir) initNodeKeysForBothStacks(nName, config_helper.keys_dir, seed, use_bls=use_bls, override=True)
def testNodeKeysChanged(looper, txnPoolNodeSet, tdir, tconf, sdk_node_theta_added, sdk_pool_handle, allPluginsPath=None): new_steward_wallet, new_node = sdk_node_theta_added new_node.stop() looper.removeProdable(name=new_node.name) nodeHa, nodeCHa = HA(*new_node.nodestack.ha), HA(*new_node.clientstack.ha) sigseed = randomString(32).encode() verkey = base58.b58encode(SimpleSigner(seed=sigseed).naclSigner.verraw).decode("utf-8") sdk_change_node_keys(looper, new_node, new_steward_wallet, sdk_pool_handle, verkey) config_helper = PNodeConfigHelper(new_node.name, tconf, chroot=tdir) initNodeKeysForBothStacks(new_node.name, config_helper.keys_dir, sigseed, override=True) logger.debug("{} starting with HAs {} {}".format(new_node, nodeHa, nodeCHa)) node = TestNode(new_node.name, config_helper=config_helper, config=tconf, ha=nodeHa, cliha=nodeCHa, pluginPaths=allPluginsPath) looper.add(node) # The last element of `txnPoolNodeSet` is the node Theta that was just # stopped txnPoolNodeSet[-1] = node looper.run(checkNodesConnected(txnPoolNodeSet)) waitNodeDataEquality(looper, node, *txnPoolNodeSet[:-1]) sdk_ensure_pool_functional(looper, txnPoolNodeSet, new_steward_wallet, sdk_pool_handle)
def poolCLI(poolCLI_baby, poolTxnData, poolTxnNodeNames, conf): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: seed = seeds[nName] use_bls = nName in poolTxnData['nodesWithBls'] initNodeKeysForBothStacks(nName, poolCLI_baby.basedirpath, seed, override=True, use_bls=use_bls) return poolCLI_baby
def poolCLI(poolCLI_baby, poolTxnData, poolTxnNodeNames, conf): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: initNodeKeysForBothStacks(nName, poolCLI_baby.basedirpath, seeds[nName], override=True) return poolCLI_baby
def tdirWithNodeKeepInited(tdir, poolTxnData, poolTxnNodeNames): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: seed = seeds[nName] use_bls = nName in poolTxnData['nodesWithBls'] initNodeKeysForBothStacks(nName, tdir, seed, use_bls=use_bls, override=True)
def initLocalKeys(tdir_for_func, tconf_for_func, nodeReg): for nName in nodeReg.keys(): sigseed = randomString(32).encode() config_helper = PNodeConfigHelper(nName, tconf_for_func, chroot=tdir_for_func) initNodeKeysForBothStacks(nName, config_helper.keys_dir, sigseed, override=True) logger.debug('Created keys for {}'.format(nName))
def poolCLI(tdir, tconf, poolCLI_baby, poolTxnData, poolTxnNodeNames, txnPoolNodeSet): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: seed = seeds[nName] use_bls = nName in poolTxnData['nodesWithBls'] config_helper = NodeConfigHelper(nName, tconf, chroot=tdir) initNodeKeysForBothStacks(nName, config_helper.keys_dir, seed, override=True, use_bls=use_bls) for node in txnPoolNodeSet: poolCLI_baby.nodes[node.name] = node return poolCLI_baby
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 addNewNode(looper, stewardClient, stewardWallet, newNodeName, tdir, tconf, allPluginsPath=None, autoStart=True, nodeClass=TestNode): sigseed = randomString(32).encode() nodeSigner = SimpleSigner(seed=sigseed) (nodeIp, nodePort), (clientIp, clientPort) = genHa(2) 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, ] } } req = stewardWallet.signOp(op) stewardClient.submitReqs(req) nodeCount = len(stewardClient.nodeReg) looper.run( eventually(checkSufficientRepliesRecvd, stewardClient.inBox, req.reqId, 1, retryWait=1, timeout=5 * nodeCount)) initNodeKeysForBothStacks(newNodeName, tdir, sigseed, override=True) node = nodeClass(newNodeName, basedirpath=tdir, config=tconf, ha=(nodeIp, nodePort), cliha=(clientIp, clientPort), pluginPaths=allPluginsPath) if autoStart: looper.add(node) return node
def start_newly_added_node(looper, node_name, tdir, sigseed, node_ha, client_ha, conf, auto_start, plugin_path, nodeClass): initNodeKeysForBothStacks(node_name, tdir, sigseed, override=True) node = nodeClass(node_name, basedirpath=tdir, config=conf, ha=node_ha, cliha=client_ha, pluginPaths=plugin_path) if auto_start: looper.add(node) return node
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 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 testNodeKeysChanged(looper, txnPoolNodeSet, tdirWithPoolTxns, tconf, steward1, nodeThetaAdded, allPluginsPath=None): newSteward, newStewardWallet, newNode = nodeThetaAdded # Since the node returned by fixture `nodeThetaAdded` was abandoned in the # previous test, so getting node `Theta` from `txnPoolNodeSet` newNode = getNodeWithName(txnPoolNodeSet, newNode.name) newNode.stop() looper.removeProdable(name=newNode.name) nodeHa, nodeCHa = HA(*newNode.nodestack.ha), HA(*newNode.clientstack.ha) sigseed = randomString(32).encode() verkey = SimpleSigner(seed=sigseed).naclSigner.verhex.decode() changeNodeKeys(looper, newSteward, newStewardWallet, newNode, verkey) initNodeKeysForBothStacks(newNode.name, tdirWithPoolTxns, sigseed, override=True) logger.debug("{} starting with HAs {} {}".format(newNode, nodeHa, nodeCHa)) node = TestNode(newNode.name, basedirpath=tdirWithPoolTxns, config=tconf, ha=nodeHa, cliha=nodeCHa, pluginPaths=allPluginsPath) looper.add(node) # The last element of `txnPoolNodeSet` is the node Theta that was just # stopped txnPoolNodeSet[-1] = node looper.run(checkNodesConnected(txnPoolNodeSet, overrideTimeout=40)) looper.run( eventually(checkNodeLedgersForEquality, node, *txnPoolNodeSet[:-1], retryWait=1, timeout=10)) ensureClientConnectedToNodesAndPoolLedgerSame(looper, steward1, *txnPoolNodeSet) ensureClientConnectedToNodesAndPoolLedgerSame(looper, newSteward, *txnPoolNodeSet)
def initialize_node_environment(name, node_config_helper, sigseed=None, override_keep=False): cleanup_environment(node_config_helper.ledger_dir) _, vk, bls_key, key_proof = initNodeKeysForBothStacks(name=name, keys_dir=node_config_helper.keys_dir, sigseed=sigseed, override=override_keep) return vk, bls_key, key_proof
def initialize_node_environment(name, base_dir, sigseed=None, override_keep=False): cleanup_environment(name, base_dir) _, vk, bls_key = initNodeKeysForBothStacks(name=name, baseDir=base_dir, sigseed=sigseed, override=override_keep) return vk, bls_key
def initialize_node_environment(name, node_config_helper, sigseed=None, override_keep=False): cleanup_environment(node_config_helper.ledger_dir) _, vk, bls_key = initNodeKeysForBothStacks( name=name, keys_dir=node_config_helper.keys_dir, sigseed=sigseed, override=override_keep) return vk, bls_key
def fake_node(txnPoolNodeSet, testNodeClass, tdir, tconf, allPluginsPath): (nodeIp, nodePort), (clientIp, clientPort) = genHa(2) newNodeName = "NewTestNode" sigseed = randomString(32).encode() config_helper = PNodeConfigHelper(newNodeName, tconf, chroot=tdir) _, verkey, bls_key = initNodeKeysForBothStacks(newNodeName, config_helper.keys_dir, sigseed, override=True) node = new_node(node_name=newNodeName, tdir=tdir, node_ha=(nodeIp, nodePort), client_ha=(clientIp, clientPort), tconf=tconf, plugin_path=allPluginsPath, nodeClass=testNodeClass) yield node node.stop()
def fake_node(txnPoolNodeSet, testNodeClass, tdir, tconf, allPluginsPath): (nodeIp, nodePort), (clientIp, clientPort) = genHa(2) newNodeName = "NewTestNode" sigseed = randomString(32).encode() config_helper = PNodeConfigHelper(newNodeName, tconf, chroot=tdir) _, verkey, bls_key, _ = initNodeKeysForBothStacks(newNodeName, config_helper.keys_dir, sigseed, override=True) node = new_node(node_name=newNodeName, tdir=tdir, node_ha=(nodeIp, nodePort), client_ha=(clientIp, clientPort), tconf=tconf, plugin_path=allPluginsPath, nodeClass=testNodeClass) yield node node.stop()
parser.add_argument('--name', required=True, help='node name') parser.add_argument('--seed', required=False, type=str, help='seed for keypair') parser.add_argument('--force', help='overrides keys', action='store_true') args = parser.parse_args() print("Node-stack name is", args.name) print("Client-stack name is", args.name + CLIENT_STACK_SUFFIX) config = getConfig() config_helper = NodeConfigHelper(args.name, config) os.makedirs(config_helper.keys_dir, exist_ok=True) try: _, verkey, blskey, key_proof = initNodeKeysForBothStacks(args.name, config_helper.keys_dir, args.seed, override=args.force) print() print("Get your key from here: ") print() print("Verkey: ") print(verkey) print("BLS: ") print(blskey) print("key_proof") print(key_proof) except Exception as ex: print(ex) exit()
def nodeThetaAdded(looper, nodeSet, tdirWithClientPoolTxns, tconf, steward, stewardWallet, allPluginsPath, testNodeClass, testClientClass, node_config_helper_class, tdir, node_name='Theta'): newStewardName = "testClientSteward" + randomString(3) newNodeName = node_name newSteward, newStewardWallet = getClientAddedWithRole( nodeSet, tdirWithClientPoolTxns, looper, steward, stewardWallet, newStewardName, role=STEWARD) sigseed = randomString(32).encode() nodeSigner = SimpleSigner(seed=sigseed) (nodeIp, nodePort), (clientIp, clientPort) = genHa(2) config_helper = node_config_helper_class(newNodeName, tconf, chroot=tdir) _, _, bls_key = initNodeKeysForBothStacks(newNodeName, config_helper.keys_dir, sigseed, override=True) data = { NODE_IP: nodeIp, NODE_PORT: nodePort, CLIENT_IP: clientIp, CLIENT_PORT: clientPort, ALIAS: newNodeName, SERVICES: [ VALIDATOR, ], BLS_KEY: bls_key } node = Node(nodeSigner.identifier, data, newStewardWallet.defaultId) newStewardWallet.addNode(node) reqs = newStewardWallet.preparePending() req = newSteward.submitReqs(*reqs)[0][0] 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)) newNode = testNodeClass(newNodeName, config_helper=config_helper, 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 bootstrapTestNodesCore( cls, config, envName, appendToLedgers, domainTxnFieldOrder, trustee_def, steward_defs, node_defs, client_defs, localNodes, nodeParamsFileName): if not localNodes: localNodes = {} try: if isinstance(localNodes, int): _localNodes = {localNodes} else: _localNodes = {int(_) for _ in localNodes} except BaseException as exc: raise RuntimeError('nodeNum must be an int or set of ints') from exc baseDir = cls.setup_base_dir(config, envName) if _localNodes else cls.setup_clibase_dir(config, envName) poolLedger = cls.init_pool_ledger(appendToLedgers, baseDir, config, envName) domainLedger = cls.init_domain_ledger(appendToLedgers, baseDir, config, envName, domainTxnFieldOrder) trustee_txn = Member.nym_txn(trustee_def.nym, trustee_def.name, verkey=trustee_def.verkey, role=TRUSTEE) domainLedger.add(trustee_txn) for sd in steward_defs: nym_txn = Member.nym_txn(sd.nym, sd.name, verkey=sd.verkey, role=STEWARD, creator=trustee_def.nym) domainLedger.add(nym_txn) key_dir = os.path.expanduser(baseDir) for nd in node_defs: if nd.idx in _localNodes: _, verkey, blskey = initNodeKeysForBothStacks(nd.name, key_dir, nd.sigseed, override=True) verkey = verkey.encode() assert verkey == nd.verkey if nd.ip != '127.0.0.1': paramsFilePath = os.path.join(baseDir, nodeParamsFileName) print('Nodes will not run locally, so writing {}'.format(paramsFilePath)) TestNetworkSetup.writeNodeParamsFile(paramsFilePath, nd.name, nd.port, nd.client_port) print("This node with name {} will use ports {} and {} for nodestack and clientstack respectively" .format(nd.name, nd.port, nd.client_port)) else: verkey = nd.verkey blskey = init_bls_keys(key_dir, nd.name, nd.sigseed) node_nym = cls.getNymFromVerkey(verkey) node_txn = Steward.node_txn(nd.steward_nym, nd.name, node_nym, nd.ip, nd.port, nd.client_port, blskey=blskey) poolLedger.add(node_txn) for cd in client_defs: txn = Member.nym_txn(cd.nym, cd.name, verkey=cd.verkey, creator=trustee_def.nym) domainLedger.add(txn) poolLedger.stop() domainLedger.stop()
def initLocalKeys(tdir, nodeReg): for nName in nodeReg.keys(): sigseed = randomString(32).encode() initNodeKeysForBothStacks(nName, tdir, sigseed, override=True) logger.debug('Created keys for {}'.format(nName))
def bootstrap_real_nodes_core(cls, config, network, appendToLedgers, domainTxnFieldOrder, trustee_def, steward_defs, node_defs, node_params_file_name, config_helper_class=PConfigHelper, node_config_helper_class=PNodeConfigHelper, chroot: str = None): # if not local_nodes: # local_nodes = {} # try: # if isinstance(local_nodes, int): # _local_nodes = {local_nodes} # else: # _local_nodes = {int(_) for _ in local_nodes} # except BaseException as exc: # raise RuntimeError('nodeNum must be an int or set of ints') from exc config.NETWORK_NAME = network config_helper = config_helper_class(config, chroot=chroot) os.makedirs(config_helper.genesis_dir, exist_ok=True) genesis_dir = config_helper.genesis_dir keys_dir = config_helper.keys_dir poolLedger = cls.init_pool_ledger(appendToLedgers, genesis_dir, config) domainLedger = cls.init_domain_ledger(appendToLedgers, genesis_dir, config, domainTxnFieldOrder) # TODO: make it parameter for generate genesis txns script genesis_protocol_version = None # 1. INIT DOMAIN LEDGER GENESIS FILE seq_no = 1 trustee_txn = Member.nym_txn(trustee_def.nym, verkey=trustee_def.verkey, role=TRUSTEE, seq_no=seq_no, protocol_version=genesis_protocol_version) seq_no += 1 domainLedger.add(trustee_txn) for sd in steward_defs: nym_txn = Member.nym_txn(sd.nym, verkey=sd.verkey, role=STEWARD, creator=trustee_def.nym, seq_no=seq_no, protocol_version=genesis_protocol_version) seq_no += 1 domainLedger.add(nym_txn) # 2. INIT KEYS AND POOL LEDGER GENESIS FILE seq_no = 1 for nd in node_defs: print( "------------------------------------------------------------------------------------------------------" ) print("Node name:", nd.name) # if nd.idx in _local_nodes: _, verkey, blskey, key_proof = initNodeKeysForBothStacks( nd.name, keys_dir, nd.sigseed, override=True) verkey = verkey.encode() assert verkey == nd.verkey # if nd.ip != '127.0.0.1': # paramsFilePath = os.path.join(config.GENERAL_CONFIG_DIR, node_params_file_name) # print('Nodes will not run locally, so writing {}'.format(paramsFilePath)) # RealNetworkSetup.writeNodeParamsFile(paramsFilePath, nd.name, # "0.0.0.0", nd.port, # "0.0.0.0", nd.client_port) print( "This node with name {} will use ports {} and {} for nodestack and clientstack respectively" .format(nd.name, nd.port, nd.client_port)) # else: # verkey = nd.verkey # blskey, key_proof = init_bls_keys(keys_dir, nd.name, nd.sigseed) node_nym = cls.get_nym_from_verkey(verkey) node_txn = Steward.node_txn( nd.steward_nym, nd.name, node_nym, nd.ip, nd.port, nd.client_port, blskey=blskey, bls_key_proof=key_proof, seq_no=seq_no, protocol_version=genesis_protocol_version) seq_no += 1 poolLedger.add(node_txn) print( "------------------------------------------------------------------------------------------------------\n" ) poolLedger.stop() domainLedger.stop()
def tdirWithNodeKeepInited(tdir, poolTxnData, poolTxnNodeNames): seeds = poolTxnData["seeds"] for nName in poolTxnNodeNames: seed = seeds[nName] initNodeKeysForBothStacks(nName, tdir, seed, override=True)
def bootstrapTestNodesCore( cls, config, network, appendToLedgers, domainTxnFieldOrder, trustee_def, steward_defs, node_defs, client_defs, localNodes, nodeParamsFileName, config_helper_class=PConfigHelper, node_config_helper_class=PNodeConfigHelper, chroot: str=None): if not localNodes: localNodes = {} try: if isinstance(localNodes, int): _localNodes = {localNodes} else: _localNodes = {int(_) for _ in localNodes} except BaseException as exc: raise RuntimeError('nodeNum must be an int or set of ints') from exc config.NETWORK_NAME = network if _localNodes: config_helper = config_helper_class(config, chroot=chroot) os.makedirs(config_helper.genesis_dir, exist_ok=True) genesis_dir = config_helper.genesis_dir keys_dir = config_helper.keys_dir else: genesis_dir = cls.setup_clibase_dir(config, network) keys_dir = os.path.join(genesis_dir, "keys") poolLedger = cls.init_pool_ledger(appendToLedgers, genesis_dir, config) domainLedger = cls.init_domain_ledger(appendToLedgers, genesis_dir, config, domainTxnFieldOrder) # 1. INIT DOMAIN LEDGER GENESIS FILE seq_no = 1 trustee_txn = Member.nym_txn(trustee_def.nym, verkey=trustee_def.verkey, role=TRUSTEE, seq_no=seq_no) seq_no += 1 domainLedger.add(trustee_txn) for sd in steward_defs: nym_txn = Member.nym_txn(sd.nym, verkey=sd.verkey, role=STEWARD, creator=trustee_def.nym, seq_no=seq_no) seq_no += 1 domainLedger.add(nym_txn) for cd in client_defs: txn = Member.nym_txn(cd.nym, verkey=cd.verkey, creator=trustee_def.nym, seq_no=seq_no) seq_no += 1 domainLedger.add(txn) # 2. INIT KEYS AND POOL LEDGER GENESIS FILE seq_no = 1 for nd in node_defs: if nd.idx in _localNodes: _, verkey, blskey = initNodeKeysForBothStacks(nd.name, keys_dir, nd.sigseed, override=True) verkey = verkey.encode() assert verkey == nd.verkey if nd.ip != '127.0.0.1': paramsFilePath = os.path.join(config.GENERAL_CONFIG_DIR, nodeParamsFileName) print('Nodes will not run locally, so writing {}'.format(paramsFilePath)) TestNetworkSetup.writeNodeParamsFile(paramsFilePath, nd.name, "0.0.0.0", nd.port, "0.0.0.0", nd.client_port) print("This node with name {} will use ports {} and {} for nodestack and clientstack respectively" .format(nd.name, nd.port, nd.client_port)) else: verkey = nd.verkey blskey = init_bls_keys(keys_dir, nd.name, nd.sigseed) node_nym = cls.getNymFromVerkey(verkey) node_txn = Steward.node_txn(nd.steward_nym, nd.name, node_nym, nd.ip, nd.port, nd.client_port, blskey=blskey, seq_no=seq_no) seq_no += 1 poolLedger.add(node_txn) poolLedger.stop() domainLedger.stop()
protocol_version=genesis_protocol_version) seq_no += 1 domainLedger.add(nym_txn) # Trustee client txn = Member.nym_txn(client_defs[node_num].nym, verkey=client_defs[node_num].verkey, creator=client_defs[node_num].nym, seq_no=seq_no, protocol_version=genesis_protocol_version) seq_no += 1 domainLedger.add(txn) # 2. INIT KEYS AND POOL LEDGER GENESIS FILE seq_no = 1 for node_num in range(nodeCountToInit): _, verkey, blskey, key_proof = initNodeKeysForBothStacks(node_defs[node_num].name, keys_dir, node_defs[node_num].sigseed, override=True) verkey = verkey.encode() assert verkey == node_defs[node_num].verkey nodeParamsFileName = 'indy.env' paramsFilePath = os.path.join(config.GENERAL_CONFIG_DIR, nodeParamsFileName) print('Nodes will not run locally, so writing {}'.format(paramsFilePath)) TestNetworkSetup.writeNodeParamsFile(paramsFilePath, node_def.name, node_def.ip, node_def.port, node_def.ip, node_def.client_port) print("This node with name {} will use ports {} and {} for nodestack and clientstack respectively" .format(node_defs[node_num].name, node_defs[node_num].port, node_defs[node_num].client_port)) node_nym = hexToFriendly(verkey)