def testTestNodeDelay(tdir_for_func):
nodeNames = {"testA", "testB"}
with TestNodeSet(names=nodeNames, tmpdir=tdir_for_func) as nodes:
nodeA = nodes.getNode("testA")
nodeB = nodes.getNode("testB")
with Looper(nodes) as looper:
for n in nodes:
n.startKeySharing()
logger.debug("connect")
looper.run(checkNodesConnected(nodes))
logger.debug("send one message, without delay")
msg = randomMsg()
looper.run(sendMsgAndCheck(nodes, nodeA, nodeB, msg, 1))
logger.debug("set delay, then send another message and find that "
"it doesn't arrive")
msg = randomMsg()
nodeB.nodeIbStasher.delay(delayerMsgTuple(6, type(msg),
nodeA.name))
with pytest.raises(AssertionError):
looper.run(sendMsgAndCheck(nodes, nodeA, nodeB, msg, 3))
logger.debug("but then find that it arrives after the delay "
"duration has passed")
looper.run(sendMsgAndCheck(nodes, nodeA, nodeB, msg, 4))
logger.debug(
"reset the delay, and find another message comes quickly")
nodeB.nodeIbStasher.resetDelays()
msg = randomMsg()
looper.run(sendMsgAndCheck(nodes, nodeA, nodeB, msg, 1))
async def sendMessageAndCheckDelivery(sender: Node,
reciever: Node,
msg: Optional[Tuple] = None,
method=None,
customTimeout=None):
"""
Sends message from one node to another and checks that it was delivered
:param sender: sender
:param reciever: recepient
:param msg: optional message - by default random one generated
:param customTimeout:
:return:
"""
logger.debug("Sending msg from {} to {}".format(sender.name,
reciever.name))
msg = msg if msg else randomMsg()
rid = sender.nodestack.getRemote(reciever.name).uid
sender.nodestack.send(msg, rid)
timeout = customTimeout or waits.expectedNodeToNodeMessageDeliveryTime()
await eventually(checkMessageReceived,
msg,
reciever,
method,
retryWait=.1,
timeout=timeout,
ratchetSteps=10)
async def sendMessageAndCheckDelivery(sender: Node,
reciever: Node,
msg: Optional[Tuple] = None,
method=None,
customTimeout=None):
"""
Sends message from one node to another and checks that it was delivered
:param sender: sender
:param reciever: recepient
:param msg: optional message - by default random one generated
:param customTimeout:
:return:
"""
logger.debug("Sending msg from {} to {}".format(sender.name, reciever.name))
msg = msg if msg else randomMsg()
rid = sender.nodestack.getRemote(reciever.name).uid
sender.nodestack.send(msg, rid)
timeout = customTimeout or waits.expectedNodeToNodeMessageDeliveryTime()
await eventually(checkMessageReceived, msg, reciever, method,
retryWait=.1,
timeout=timeout,
ratchetSteps=10)
def testMsgSendingTime(pool, nodeReg):
nodeNames = list(nodeReg.keys())
msg = randomMsg()
pool.looper.run(
sendMsgAndCheck(pool.nodeset,
nodeNames[0],
nodeNames[1],
msg,
1))
def testMsgSendingTime(pool):
nodes = pool.nodeset
msg = randomMsg()
timeout = waits.expectedNodeStartUpTimeout()
pool.looper.run(
sendMessageAndCheckDelivery(nodes[0],
nodes[1],
msg,
customTimeout=timeout))
def testMsgSendingTime(pool, nodeReg):
nodeNames = list(nodeReg.keys())
msg = randomMsg()
timeout = waits.expectedNodeStartUpTimeout()
pool.looper.run(
sendMessageAndCheckDelivery(pool.nodeset,
nodeNames[0],
nodeNames[1],
msg,
customTimeout=timeout))
async def sendMsgAndCheck(nodes: TestNodeSet,
frm: NodeRef,
to: NodeRef,
msg: Optional[Tuple]=None,
timeout: Optional[int]=15
):
logger.debug("Sending msg from {} to {}".format(frm, to))
msg = msg if msg else randomMsg()
frmnode = nodes.getNode(frm)
rid = frmnode.nodestack.getRemote(nodes.getNodeName(to)).uid
frmnode.nodestack.send(msg, rid)
await eventually(checkMsg, msg, nodes, to, retryWait=.1, timeout=timeout,
ratchetSteps=10)
async def sendMsgAndCheck(nodes: TestNodeSet,
frm: NodeRef,
to: NodeRef,
msg: Optional[Tuple] = None,
timeout: Optional[int] = 15):
msg = msg if msg else randomMsg()
sendMsg(nodes, frm, to, msg)
await eventually(checkMsg,
msg,
nodes,
to,
retryWait=.1,
timeout=timeout,
ratchetSteps=10)
def sendMessage(sender: Node, reciever: Node, msg: Optional[Tuple] = None):
"""
Sends message from one node to another
:param nodes:
:param sender: sender
:param reciever: recepient
:param msg: optional message - by default random one generated
:return:
"""
logger.debug("Sending msg from {} to {}".format(sender.name,
reciever.name))
msg = msg if msg else randomMsg()
rid = sender.nodestack.getRemote(reciever.name).uid
sender.nodestack.send(msg, rid)
def sendMessage(sender: Node,
reciever: Node,
msg: Optional[Tuple] = None):
"""
Sends message from one node to another
:param nodes:
:param sender: sender
:param reciever: recepient
:param msg: optional message - by default random one generated
:return:
"""
logger.debug("Sending msg from {} to {}".format(sender.name, reciever.name))
msg = msg if msg else randomMsg()
rid = sender.nodestack.getRemote(reciever.name).uid
sender.nodestack.send(msg, rid)
def sendMessage(nodes: TestNodeSet,
frm: NodeRef,
to: NodeRef,
msg: Optional[Tuple] = None):
"""
Sends message from one node to another
:param nodes:
:param frm: sender
:param to: recepient
:param msg: optional message - by default random one generated
:return:
"""
logger.debug("Sending msg from {} to {}".format(frm, to))
msg = msg if msg else randomMsg()
sender = nodes.getNode(frm)
rid = sender.nodestack.getRemote(nodes.getNodeName(to)).uid
sender.nodestack.send(msg, rid)
def testMsgSendingTime(pool, nodeReg):
nodeNames = list(nodeReg.keys())
msg = randomMsg()
pool.looper.run(
sendMsgAndCheck(pool.nodeset, nodeNames[0], nodeNames[1], msg, 1))
