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 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 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 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 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 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]
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)
