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 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 create_and_prep_stacks(names, tdir, looper): genKeys(tdir, names) printers = [Printer(n) for n in names] stacks = [ZStack(n, ha=genHa(), basedirpath=tdir, msgHandler=printers[i].print, restricted=True) for i, n in enumerate(names)] prepStacks(looper, *stacks, connect=True, useKeys=True) return stacks, printers
def test_reconnect_multiple_time(looper, create_stacks): alpha, beta, beta_msg_handler = create_stacks prepStacks(looper, *[alpha, beta], connect=True, useKeys=True) num_msg = 50 send(looper, alpha, beta, num_msg) check_all_received(looper, frm=alpha, to_msg_handler=beta_msg_handler, num_msg=num_msg) total = num_msg for i in range(10): beta.stop() num_msg = random.Random().randint(1, 100) total += num_msg send(looper, alpha, beta, num_msg) looper.runFor(random.Random().randint(1, 10)) beta.start() connectStack(beta, alpha) check_all_received(looper, frm=alpha, to_msg_handler=beta_msg_handler, num_msg=total)
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 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 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 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 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 create_and_prep_stacks(names, basedir, looper, conf): genKeys(basedir, names) printers = [Printer(n) for n in names] # adict is used below to copy the config module since one stack might # have different config from others stacks = [ZStack(n, ha=genHa(), basedirpath=basedir, msgHandler=printers[i].print, restricted=True, config=adict(**conf.__dict__)) for i, n in enumerate(names)] prepStacks(looper, *stacks, connect=True, useKeys=True) return stacks, printers
def create_alpha(tdir, looper, name): alphaP = Printer(name) alpha = ZStack(name, ha=genHa(), basedirpath=tdir, msgHandler=alphaP.print, restricted=True) prepStacks(looper, alpha, connect=False) patch_ping_pong(alpha) return alpha
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 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 create_beta(tdir, looper, name, start_stack=True): beta_msg_handler = CounterMsgsHandler() beta = ZStack(name, ha=genHa(), basedirpath=tdir, msgHandler=beta_msg_handler.handler, restricted=True) if start_stack: prepStacks(looper, beta, connect=False) patch_ping_pong(beta) return beta, beta_msg_handler
def testKitZStacksConnected(registry, tdir, looper): genKeys(tdir, registry.keys()) stacks = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auto=0) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stacks.append(stack) prepStacks(looper, *stacks, connect=False, useKeys=True) looper.run(eventually(checkStacksConnected, stacks, retryWait=1, timeout=10))
def testKitZStacksCommunication(registry, tdir, looper): # TODO: Use a packet capture tool genKeys(tdir, registry.keys()) stacks = [] names = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stacks.append(stack) names.append((name, printer)) prepStacks(looper, *stacks, connect=False, useKeys=True) # TODO: the connection may not be established for the first try because # some of the stacks may not have had a remote yet (that is they haven't had yet called connect) timeout = 4 * KITZStack.RETRY_TIMEOUT_RESTRICTED + 1 looper.run(eventually( checkStacksConnected, stacks, retryWait=1, timeout=timeout)) def send_recv(): for i, j in combinations(range(len(stacks)), 2): alpha = stacks[i] beta = stacks[j] alpha.send({'greetings': 'hi'}, beta.name) beta.send({'greetings': 'hello'}, alpha.name) looper.run( eventually(chkPrinted, names[i][1], {'greetings': 'hello'}, timeout=15)) looper.run(eventually(chkPrinted, names[j][1], { 'greetings': 'hi'}, timeout=15)) names[i][1].reset() names[j][1].reset() def pr(): for stack in stacks: for r in stack.remotes.values(): print(r._lastSocketEvents()) for _ in range(100): # send_recv() looper.run(eventually( checkStacksConnected, stacks, retryWait=1, timeout=timeout)) # pr() looper.runFor(30)
def create_stack(name, looper, tdir, tconf): msh_handler = CounterMsgsHandler() stackParams = dict(name=name, ha=REGISTRY[name], basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) stack = KITZStack(stackParams, msgHandler=msh_handler.handler, registry=REGISTRY, config=tconf) motor = prepStacks(looper, *[stack], connect=False, useKeys=True)[0] return stack, motor, msh_handler
def connected_nodestacks(registry, tdir, looper, connection_timeout, tconf): genKeys(tdir, registry.keys()) stacks = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stack.listenerQuota = tconf.NODE_TO_NODE_STACK_QUOTA stack.listenerSize = tconf.NODE_TO_NODE_STACK_SIZE stacks.append(stack) motors = prepStacks(looper, *stacks, connect=False, useKeys=True) looper.run( eventually(checkStacksConnected, stacks, retryWait=1, timeout=connection_timeout)) return stacks, motors
def test_high_load(tdir, looper, tconf): """ Checks whether ZStack can cope with high message rate """ letters = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' ] num_of_senders = 3 num_of_requests_per_sender = 100000 expected_messages = [] received_messages = [] def handler(wrapped_message): msg, sender = wrapped_message received_messages.append(msg) def create_stack(name, handler=None): return ZStack(name, ha=genHa(), basedirpath=tdir, msgHandler=handler, restricted=False, seed=randomSeed(), config=tconf) senders = [create_stack(letter) for letter in letters[:num_of_senders]] gamma = create_stack("Gamma", handler) prepStacks(looper, *senders, gamma, connect=True, useKeys=True) for i in range(num_of_requests_per_sender): for sender in senders: msg = {sender.name: i} expected_messages.append(msg) sender.send(msg, gamma.name) looper.runFor(5) assert len(received_messages) != 0 assert len(expected_messages) == len(received_messages), \ "{} != {}, LAST IS {}"\ .format(len(expected_messages), len(received_messages), received_messages[-1])
def testKitZStacksConnected(registry, tdir, looper, tconf): genKeys(tdir, registry.keys()) stacks = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stacks.append(stack) prepStacks(looper, *stacks, connect=False, useKeys=True) # TODO: the connection may not be established for the first try because # some of the stacks may not have had a remote yet (that is they haven't had yet called connect) timeout = 2*tconf.RETRY_TIMEOUT_RESTRICTED+1 looper.run(eventually( checkStacksConnected, stacks, retryWait=1, timeout=timeout))
def create_stack(name, looper, tdir, tconf): printer = Printer(name) stackParams = dict(name=name, ha=REGISTRY[name], basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) stack = KITZStack(stackParams, msgHandler=printer.print, registry=REGISTRY, config=tconf) patch_ping_pong(stack) motor = prepStacks(looper, *[stack], connect=False, useKeys=True)[0] return stack, motor
def test_no_size_limit_for_outbound_msgs(looper, tdir, msg): names = ['Alpha', 'Beta'] genKeys(tdir, names) alpha = ZStack(names[0], ha=genHa(), basedirpath=tdir, msgHandler=None, restricted=False) alpha.msgLenVal.max_allowed = MSG_LEN_LIMIT beta_msg_handler = CounterMsgsHandler() beta = ZStack(names[1], ha=genHa(), basedirpath=tdir, msgHandler=beta_msg_handler.handler, restricted=False) prepStacks(looper, alpha, beta) def check_received(value): assert beta_msg_handler.receivedMsgCount == value alpha.send(msg) looper.run(eventually(check_received, 1, retryWait=1, timeout=10))
def testKitZStacksConnected(registry, tdir, looper, tconf): genKeys(tdir, registry.keys()) stacks = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stacks.append(stack) prepStacks(looper, *stacks, connect=False, useKeys=True) # TODO: the connection may not be established for the first try because # some of the stacks may not have had a remote yet (that is they haven't had yet called connect) timeout = 2 * tconf.RETRY_TIMEOUT_RESTRICTED + 1 looper.run(eventually( checkStacksConnected, stacks, retryWait=1, timeout=timeout))
def stacks(registry, tdir, looper, printers): rstacks = [] for name, ha in registry.items(): printer = printers[name] stackParams = { "name": name, "ha": ha, "auto": AutoMode.always, "main": True, "mutable": "mutable", "messageTimeout": 30, "basedirpath": tdir } reg = copy(registry) reg.pop(name) stack = KITRStack(stackParams, printer.print, reg) rstacks.append(stack) prepStacks(looper, *rstacks, connect=True, useKeys=False) return rstacks
def test_high_load(set_info_log_level, tdir, looper, tconf): """ Checks whether ZStack can cope with high message rate """ letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] num_of_senders = 3 num_of_requests_per_sender = BIG_NUM_OF_MSGS expected_messages = [] received_messages = [] def handler(wrapped_message): msg, sender = wrapped_message received_messages.append(msg) def create_stack(name, handler=None): return ZStack(name, ha=genHa(), basedirpath=tdir, msgHandler=handler, restricted=False, seed=randomSeed(), config=tconf) senders = [create_stack(letter) for letter in letters[:num_of_senders]] gamma = create_stack("Gamma", handler) prepStacks(looper, *senders, gamma, connect=True, useKeys=True) for sender in senders: for i in range(num_of_requests_per_sender): msg = {sender.name: i} expected_messages.append(msg) sender.send(msg, gamma.name) looper.runFor(5) assert len(received_messages) != 0 assert len(expected_messages) == len(received_messages), \ "{} != {}, LAST IS {}"\ .format(len(expected_messages), len(received_messages), received_messages[-1])
def test2RStackCommunication(tdir, looper): names = ['Alpha', 'Beta'] alphaP = Printer(names[0]) betaP = Printer(names[1]) stackParamsAlpha = { "name": names[0], "ha": genHa(), "auto": AutoMode.always, "main": True, "mutable": "mutable", "messageTimeout": 30, "basedirpath": tdir } stackParamsBeta = { "name": names[1], "ha": genHa(), "main": True, "auto": AutoMode.always, "mutable": "mutable", "messageTimeout": 30, "basedirpath": tdir } alpha = SimpleRStack(stackParamsAlpha, msgHandler=alphaP.print) beta = SimpleRStack(stackParamsBeta, msgHandler=betaP.print) alpha.connect(ha=beta.ha) beta.connect(ha=alpha.ha) prepStacks(looper, alpha, beta, connect=False, useKeys=False) looper.run( eventually(checkStacksConnected, [alpha, beta], retryWait=1, timeout=10)) alpha.send({'greetings': 'hi Beta'}, beta.name) beta.send({'greetings': 'hi Alpha'}, alpha.name) looper.run(eventually(chkPrinted, betaP, {'greetings': 'hi Beta'})) looper.run(eventually(chkPrinted, alphaP, {'greetings': 'hi Alpha'}))
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_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 send_to_disconnected_then_connect(send_to_disconnected, looper, ping_pong_drop_strategy, reconnect_strategy, round): # 1. send to disconnected stack alpha, beta, beta_msg_handler = send_to_disconnected # 2. reconnect Alpha if reconnect_strategy == 'reconnect': alpha.reconnectRemoteWithName(beta.name) prepStacks(looper, beta, connect=False) # 3. Make sure that ping (pong) is the first message received by Alpha # dropping pong (ping) if ping_pong_drop_strategy == 'ping_first': drop_pongs(alpha) elif ping_pong_drop_strategy == 'pong_first': drop_pings(alpha) # 4. Connect beta to alpha connectStack(beta, alpha) # 5. make sure that ping (pong) is the first message received by Alpha if ping_pong_drop_strategy == 'ping_first': check_ping_received(looper, alpha, beta.name) assert not alpha.isConnectedTo(beta.name) elif ping_pong_drop_strategy == 'pong_first': check_pong_received(looper, alpha, beta.name) assert beta.name not in alpha.has_ping # 6. make sure that dropped pong (ping) is received to establish connection if ping_pong_drop_strategy == 'ping_first': re_send_pong(alpha, beta) check_ping_received(looper, alpha, beta.name) check_pong_received(looper, alpha, beta.name) elif ping_pong_drop_strategy == 'pong_first': re_send_ping(alpha, beta) check_ping_received(looper, alpha, beta.name) check_pong_received(looper, alpha, beta.name) return alpha, beta, beta_msg_handler
def connected_stacks(registry, tdir, looper, connection_timeout): genKeys(tdir, registry.keys()) stacks = [] for name, ha in registry.items(): printer = Printer(name) stackParams = dict(name=name, ha=ha, basedirpath=tdir, auth_mode=AuthMode.RESTRICTED.value) reg = copy(registry) reg.pop(name) stack = KITZStack(stackParams, printer.print, reg) stacks.append(stack) motors = prepStacks(looper, *stacks, connect=False, useKeys=True) looper.run(eventually( checkStacksConnected, stacks, retryWait=1, timeout=connection_timeout)) return stacks, motors