def _generate_genesis_files(self):
pool_txns, domain_txns = self._split_pool_and_domain()
# TODO make Ledger a context manager
pl = TestNetworkSetup.init_pool_ledger(appendToLedgers=False,
baseDir=self.base_dir,
config=self.config,
envName='test')
pl_lines = self._add_and_stop(pool_txns, pl)
dl = TestNetworkSetup.init_domain_ledger(
appendToLedgers=False,
baseDir=self.base_dir,
config=self.config,
envName='test',
domainTxnFieldOrder=getTxnOrderedFields())
dl_lines = self._add_and_stop(domain_txns, dl)
return adict(pool=adict(lines=pl_lines,
root=pl.root_hash,
size=pl.size),
domain=adict(lines=dl_lines,
root=dl.root_hash,
size=dl.size))
def _generate_genesis_files(self):
pool_txns, domain_txns = self._split_pool_and_domain()
# TODO make Ledger a context manager
pl = TestNetworkSetup.init_pool_ledger(appendToLedgers=False,
baseDir=self.base_dir,
config=self.config,
envName='test')
pl_lines = self._add_and_stop(pool_txns, pl)
dl = TestNetworkSetup.init_domain_ledger(
appendToLedgers=False,
baseDir=self.base_dir,
config=self.config,
envName='test',
domainTxnFieldOrder=getTxnOrderedFields())
dl_lines = self._add_and_stop(domain_txns, dl)
return adict(pool=adict(lines=pl_lines,
root=pl.root_hash,
size=pl.size),
domain=adict(lines=dl_lines,
root=dl.root_hash,
size=dl.size))
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
for node in A, B:
makeNodeFaulty(node, changesRequest)
node.delaySelfNomination(10)
return adict(faulties=(A, B))
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
for node in A, B:
makeNodeFaulty(node, partial(delaysPrePrepareProcessing, delay=60))
node.delaySelfNomination(10)
return adict(faulties=(A, B))
def setup(looper, startedNodes, up, wallet1, client1):
# Get the master replica of the master protocol instance
P = getPrimaryReplica(startedNodes)
# Make `Delta` small enough so throughput check passes.
for node in startedNodes:
node.monitor.Delta = .001
slowRequest = None
# make P (primary replica on master) faulty, i.e., slow to send
# PRE-PREPARE for a specific client request only
def by65SpecificPrePrepare(msg):
nonlocal slowRequest
if isinstance(msg, PrePrepare) and slowRequest is None:
slowRequest = getattr(msg, f.REQ_ID.nm)
return 65
P.outBoxTestStasher.delay(by65SpecificPrePrepare)
sendReqsToNodesAndVerifySuffReplies(looper,
wallet1,
client1,
numReqs=5,
timeoutPerReq=80)
return adict(nodes=startedNodes)
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
for node in A, B:
makeNodeFaulty(node, changesRequest)
node.delaySelfNomination(10)
return adict(faulties=(A, B))
def setup(nodeSet):
gn = [v for k, v in nodeSet.nodes.items() if k != 'Alpha']
# delay incoming client messages for good nodes by 250 milliseconds
# this gives Alpha a chance to send a propagate message
for n in gn: # type: TestNode
n.clientIbStasher.delay(lambda _: 1)
return adict(goodNodes=gn)
def setup(nodeSet):
gn = [v for k, v in nodeSet.nodes.items() if k != 'Alpha']
# delay incoming client messages for good nodes by 250 milliseconds
# this gives Alpha a chance to send a propagate message
for n in gn: # type: TestNode
n.clientIbStasher.delay(lambda _: 1)
return adict(goodNodes=gn)
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 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 setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
for node in A, B:
makeNodeFaulty(node,
partial(delaysPrePrepareProcessing, delay=60))
node.delaySelfNomination(10)
return adict(faulties=(A, B))
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
# The primary replica would send PRE-PREPARE messages with incorrect digest
makeNodeFaulty(primaryRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=PrePrepare))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps)
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
G = startedNodes.Gamma
for node in A, B, G:
makeNodeFaulty(node, changesRequest,
partial(delaysPrePrepareProcessing, delay=90))
node.delaySelfNomination(10)
return adict(faulties=(A, B, G))
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
G = startedNodes.Gamma
for node in A, B, G:
makeNodeFaulty(node, changesRequest, partial(delaysPrePrepareProcessing,
delay=90))
node.delaySelfNomination(10)
return adict(faulties=(A, B, G))
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
# The primary replica would send PRE-PREPARE messages with incorrect digest
makeNodeFaulty(primaryRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=PrePrepare))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps)
def setup(startedNodes):
A = startedNodes.Alpha
B = startedNodes.Beta
# Delay processing of PRE-PREPARE messages by Alpha and Beta for 90
# seconds since the timeout for checking sufficient commits is 60 seconds
makeNodeFaulty(A, partial(delaysPrePrepareProcessing, delay=90))
makeNodeFaulty(B, partial(delaysPrePrepareProcessing, delay=90))
A.delaySelfNomination(10)
B.delaySelfNomination(10)
return adict(faulties=(A, B))
def setup(nodeSet, up):
primaryRep = getPrimaryReplica(nodeSet, 0)
nonPrimaryReps = getNonPrimaryReplicas(nodeSet, 0)
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(faultyRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=Commit, instId=0))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def setup(nodeSet, up):
primaryRep = getPrimaryReplica(nodeSet, 0)
nonPrimaryReps = getNonPrimaryReplicas(nodeSet, 0)
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(faultyRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=Commit, instId=0))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def run(self, coro, nodecount=4):
tmpdir = self.fresh_tdir()
with self.testNodeSetClass(count=nodecount, tmpdir=tmpdir) as nodeset:
with Looper(nodeset) as looper:
for n in nodeset:
n.startKeySharing()
ctx = adict(looper=looper, nodeset=nodeset, tmpdir=tmpdir)
looper.run(checkNodesConnected(nodeset))
ensureElectionsDone(looper=looper, nodes=nodeset, retryWait=1,
timeout=30)
looper.run(coro(ctx))
def step1(looper, nodeSet, up, wallet1, client1):
startedNodes = nodeSet
"""
stand up a pool of nodes and send 5 requests to client
"""
# the master instance has a primary replica, call it P
P = getPrimaryReplica(startedNodes)
requests = sendReqsToNodesAndVerifySuffReplies(looper, wallet1, client1, 5)
# profile_this(sendReqsToNodesAndVerifySuffReplies, looper, client1, 5)
return adict(P=P, nodes=startedNodes, requests=requests)
def setup(txnPoolNodeSet):
primaryRep, nonPrimaryReps = getPrimaryReplica(txnPoolNodeSet, 0), \
getNonPrimaryReplicas(txnPoolNodeSet, 0)
# A non primary replica sends PREPARE messages with incorrect digest
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(faultyRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=Prepare, instId=0))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
# A non primary replica sends PREPARE messages with incorrect digest
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(faultyRep.node, partial(send3PhaseMsgWithIncorrectDigest,
msgType=Prepare, instId=0))
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def run(self, coro, nodecount=4):
tmpdir = self.fresh_tdir()
with self.testNodeSetClass(count=nodecount, tmpdir=tmpdir) as nodeset:
with Looper(nodeset) as looper:
for n in nodeset:
n.startKeySharing()
ctx = adict(looper=looper, nodeset=nodeset, tmpdir=tmpdir)
looper.run(checkNodesConnected(nodeset))
ensureElectionsDone(looper=looper,
nodes=nodeset,
retryWait=1,
timeout=30)
looper.run(coro(ctx))
def setup(txnPoolNodeSet):
primaryRep, nonPrimaryReps = getPrimaryReplica(txnPoolNodeSet, 0), \
getNonPrimaryReplicas(txnPoolNodeSet, 0)
# The primary replica would send 3 duplicate PRE-PREPARE requests to
# non primary replicas
makeNodeFaulty(primaryRep.node, partial(sendDuplicate3PhaseMsg,
msgType=PrePrepare, count=3))
# The node of the primary replica above should not be blacklisted by any
# other node since we are simulating multiple PRE-PREPARE messages and
# want to check for a particular suspicion
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps)
def step1(looper, nodeSet, up, client1):
startedNodes = nodeSet
"""
stand up a pool of nodes and send 5 requests to client
"""
# the master instance has a primary replica, call it P
P = getPrimaryReplica(startedNodes)
requests = sendReqsToNodesAndVerifySuffReplies(looper, client1, 5)
# profile_this(sendReqsToNodesAndVerifySuffReplies, looper, client1, 5)
return adict(P=P,
nodes=startedNodes,
requests=requests)
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
# The primary replica would send 3 duplicate PRE-PREPARE requests to
# non primary replicas
makeNodeFaulty(primaryRep.node, partial(sendDuplicate3PhaseMsg,
msgType=PrePrepare, count=3))
# The node of the primary replica above should not be blacklisted by any
# other node since we are simulating multiple PRE-PREPARE messages and
# want to check for a particular suspicion
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps)
def create_local_pool(node_base_dir, cli_base_dir, config=None, node_size=4):
conf = config or getConfig()
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
node_config_helper = NodeConfigHelper(conf.name,
conf,
chroot=node_base_dir)
n_config = adict(name='Node' + str(i + 1),
basedirpath=node_config_helper.ledger_dir,
ha=('127.0.0.1', 9700 + (i * 2)),
cliha=('127.0.0.1', 9700 + (i * 2) + 1))
n_verkey, n_bls_key, n_bls_key_proof = \
initialize_node_environment(name=n_config.name,
node_config_helper=node_config_helper,
override_keep=True,
sigseed=randomSeed())
s.set_node(n_config,
verkey=n_verkey,
blskey=n_bls_key,
blsley_proof=n_bls_key_proof)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = None # LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def create_local_pool(base_dir, node_size=4):
conf = getConfig(base_dir)
pool_dir = os.path.join(base_dir, "pool")
# TODO: Need to come back to this why we need this cleanup
shutil.rmtree(pool_dir, ignore_errors=True)
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
n_config = adict(name='Node' + str(i + 1),
basedirpath=pool_dir,
ha=('127.0.0.1', 9700 + (i * 2)),
cliha=('127.0.0.1', 9700 + (i * 2) + 1))
n_verkey, n_bls_key = initialize_node_environment(
name=n_config.name,
base_dir=n_config.basedirpath,
override_keep=True,
config=conf,
sigseed=randomSeed())
s.set_node(n_config, verkey=n_verkey, blskey=n_bls_key)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def create_local_pool(base_dir, node_size=4):
conf = getConfig(base_dir)
pool_dir = os.path.join(base_dir, "pool")
# TODO: Need to come back to this why we need this cleanup
shutil.rmtree(pool_dir, ignore_errors=True)
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
n_config = adict(name='Node'+str(i+1),
basedirpath=pool_dir,
ha=('127.0.0.1', 9700+(i * 2)),
cliha=('127.0.0.1', 9700+(i * 2)+1))
n_verkey = initialize_node_environment(name=n_config.name,
base_dir=n_config.basedirpath,
override_keep=True,
config=conf,
sigseed=randomSeed())
s.set_node(n_config, verkey=n_verkey)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def setup(looper, startedNodes, up, client1):
# Get the master replica of the master protocol instance
P = getPrimaryReplica(startedNodes)
# Make `Delta` small enough so throughput check passes.
for node in startedNodes:
node.monitor.Delta = .001
# make P (primary replica on master) faulty, i.e., slow to send
# PRE-PREPARE for a specific client request only
def by65SpecificPrePrepare(msg):
if isinstance(msg, PrePrepare) and getattr(msg, f.REQ_ID.nm) == 2:
return 65
P.outBoxTestStasher.delay(by65SpecificPrePrepare)
sendReqsToNodesAndVerifySuffReplies(looper, client1, numReqs=5, timeout=80)
return adict(nodes=startedNodes)
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(faultyRep.node, partial(sendDuplicate3PhaseMsg,
msgType=Commit, count=3,
instId=0))
# The node of the primary replica above should not be blacklisted by any
# other node since we are simulating multiple COMMIT messages and
# want to check for a particular suspicion
whitelistNode(faultyRep.node.name,
[node for node in nodeSet if node != faultyRep.node],
Suspicions.DUPLICATE_CM_SENT.code)
return adict(primaryRep=primaryRep, nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def setup(nodeSet, up):
primaryRep, nonPrimaryReps = getPrimaryReplica(nodeSet, 0), \
getNonPrimaryReplicas(nodeSet, 0)
faultyRep = nonPrimaryReps[0]
makeNodeFaulty(
faultyRep.node,
partial(sendDuplicate3PhaseMsg, msgType=Commit, count=3, instId=0))
# The node of the primary replica above should not be blacklisted by any
# other node since we are simulating multiple COMMIT messages and
# want to check for a particular suspicion
whitelistNode(faultyRep.node.name,
[node for node in nodeSet if node != faultyRep.node],
Suspicions.DUPLICATE_CM_SENT.code)
return adict(primaryRep=primaryRep,
nonPrimaryReps=nonPrimaryReps,
faultyRep=faultyRep)
def create_local_pool(node_base_dir, cli_base_dir, config=None, node_size=4):
conf = config or getConfig()
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
node_config_helper = NodeConfigHelper(conf.name, conf, chroot=node_base_dir)
n_config = adict(name='Node' + str(i + 1),
basedirpath=node_config_helper.ledger_dir,
ha=('127.0.0.1', 9700 + (i * 2)),
cliha=('127.0.0.1', 9700 + (i * 2) + 1))
n_verkey, n_bls_key = initialize_node_environment(name=n_config.name,
node_config_helper=node_config_helper,
override_keep=True,
sigseed=randomSeed())
s.set_node(n_config, verkey=n_verkey, blskey=n_bls_key)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = None # LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def setup(startedNodes):
A = startedNodes.Alpha
A.delaySelfNomination(10)
makeNodeFaulty(A,
partial(delaysPrePrepareProcessing, delay=60))
return adict(faulty=A)
def pool(looper, nodeSet):
for n in nodeSet: # type: TestNode
n.startKeySharing()
looper.run(checkNodesConnected(nodeSet))
checkProtocolInstanceSetup(looper, nodeSet, timeout=5)
return adict(looper=looper, nodeset=nodeSet)
def setup(startedNodes):
A = startedNodes.Alpha
A.delaySelfNomination(10)
makeNodeFaulty(A, partial(delaysPrePrepareProcessing, delay=60))
return adict(faulty=A)
def symEncData(attributeData):
encData, secretKey = getSymmetricallyEncryptedVal(attributeData)
return adict(data=attributeData, encData=encData, secretKey=secretKey)
def pool(looper, nodeSet):
for n in nodeSet: # type: TestNode
n.startKeySharing()
looper.run(checkNodesConnected(nodeSet))
checkProtocolInstanceSetup(looper, nodeSet, timeout=5)
return adict(looper=looper, nodeset=nodeSet)
def symEncData(attributeData):
encData, secretKey = getSymmetricallyEncryptedVal(attributeData)
return adict(data=attributeData, encData=encData, secretKey=secretKey)
