def test_zstack_non_utf8(tdir, looper, tconf): """ ZStack gets a non utf-8 message and does not hand it over to the processing method :return: """ names = ['Alpha', 'Beta'] genKeys(tdir, names) (alpha, beta), (alphaP, betaP) = create_and_prep_stacks(names, tdir, looper, tconf) # Send a utf-8 message and see its received for uid in alpha.remotes: alpha.transmit(b'{"k1": "v1"}', uid, serialized=True) looper.run(eventually(chkPrinted, betaP, {"k1": "v1"})) # Send a non utf-8 message and see its not received (by the receiver method) for uid in alpha.remotes: alpha.transmit(b'{"k2": "v2\x9c"}', uid, serialized=True) with pytest.raises(AssertionError): looper.run(eventually(chkPrinted, betaP, {"k2": "v2\x9c"})) # TODO: A better test where the output of the parsing method is checked # requires spyable methods # Again send a utf-8 message and see its received (checks if stack is # functional after receiving a bad message) for uid in alpha.remotes: alpha.transmit(b'{"k3": "v3"}', uid, serialized=True) looper.run(eventually(chkPrinted, betaP, {"k3": "v3"}))
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 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 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 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 test_zstack_non_utf8(tdir, looper, tconf): """ ZStack gets a non utf-8 message and does not hand it over to the processing method :return: """ names = ['Alpha', 'Beta'] genKeys(tdir, names) (alpha, beta), (alphaP, betaP) = create_and_prep_stacks(names, tdir, looper, tconf) # Send a utf-8 message and see its received for uid in alpha.remotes: alpha.transmit(b'{"k1": "v1"}', uid, serialized=True) looper.run(eventually(chkPrinted, betaP, {"k1": "v1"})) # Send a non utf-8 message and see its not received (by the receiver method) for uid in alpha.remotes: alpha.transmit(b'{"k2": "v2\x9c"}', uid, serialized=True) with pytest.raises(AssertionError): looper.run(eventually(chkPrinted, betaP, {"k2": "v2\x9c"})) # TODO: A better test where the output of the parsing method is checked # requires spyable methods # Again send a utf-8 message and see its received (checks if stack is # functional after receiving a bad message) for uid in alpha.remotes: alpha.transmit(b'{"k3": "v3"}', uid, serialized=True) looper.run(eventually(chkPrinted, betaP, {"k3": "v3"}))
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 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 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 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 create_stacks(tdir, looper): names = ['Alpha', 'Beta'] genKeys(tdir, names) alpha = create_alpha(tdir, names[0]) beta, beta_msg_handler = create_beta(tdir, names[1]) return alpha, beta, beta_msg_handler
def clientstack(tdir, looper, alpha_handler): names = ['ClientA', 'Alpha'] genKeys(tdir, names) aseed = randomSeed() cseed = randomSeed() stackParams = { "name": names[0], "ha": genHa(), "auto": 2, "basedirpath": tdir } timer = MockTimer(0) client = ClientZStack(stackParams, alpha_handler.handle, cseed, False, timer=timer) stackParams = { "name": names[1], "ha": genHa(), "auto": 2, "basedirpath": tdir } timer = MockTimer(0) alpha = SimpleZStack(stackParams, alpha_handler, aseed, True, timer=timer) amotor = SMotor(alpha) looper.add(amotor) cmotor = SMotor(client) looper.add(cmotor) return alpha, client
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 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 testNodeConnection(allPluginsPath, tdirAndLooper, nodeReg, conf): console = getConsole() console.reinit(flushy=True, verbosity=console.Wordage.verbose) tdir, looper = tdirAndLooper names = ["Alpha", "Beta"] if conf.UseZStack: genKeys(tdir, names + [_ + CLIENT_STACK_SUFFIX for _ in names]) logger.debug(names) nrg = {n: nodeReg[n] for n in names} A, B = [ TestNode(name, nrg, basedirpath=tdir, pluginPaths=allPluginsPath) for name in names ] looper.add(A) looper.runFor(4) logger.debug("wait done") looper.add(B) looper.runFor(4) looper.run(checkNodesConnected([A, B])) looper.stopall() A.start(looper.loop) looper.runFor(4) B.start(looper.loop) looper.run(checkNodesConnected([A, B])) stopNodes([A, B], looper)
def testNodesConnectsWhenOneNodeIsLate(allPluginsPath, tdirAndLooper, nodeReg, conf): tdir, looper = tdirAndLooper nodes = [] names = list(nodeReg.keys()) logger.debug("Node names: {}".format(names)) def create(name): node = TestNode(name, nodeReg, basedirpath=tdir, pluginPaths=allPluginsPath) looper.add(node) nodes.append(node) # TODO: This will be moved to a fixture if conf.UseZStack: genKeys(tdir, names + [_ + CLIENT_STACK_SUFFIX for _ in names]) for name in names[:3]: create(name) looper.run(checkNodesConnected(nodes)) # wait for the election to complete with the first three nodes looper.runFor(10) # create the fourth and see that it learns who the primaries are # from the other nodes create(names[3]) checkProtocolInstanceSetup(looper, nodes, timeout=10) stopNodes(nodes, looper)
def create_stacks(tdir, looper, reconnect_strategy): names = ['Alpha', 'Beta'] genKeys(tdir, names) alpha = create_alpha(tdir, looper, names[0]) beta, beta_msg_handler = create_beta(tdir, looper, names[1], start_stack=reconnect_strategy != 'reconnect') return alpha, beta, beta_msg_handler
def testSimpleZStacksMsgs(tdir, looper): names = ['Alpha', 'Beta'] genKeys(tdir, names) names = ['Alpha', 'Beta'] aseed = randomSeed() bseed = randomSeed() size = 100000 msg = json.dumps({'random': randomSeed(size).decode()}).encode() def aHandler(m): str_m = "{}".format(m) print('{} printing... {}'.format(names[0], str_m[:100])) d, _ = m print('Message size is {}'.format(len(d['random']))) assert len(d['random']) == size def bHandler(m): print(beta.msgHandler) a = m[1] try: beta.listener.send_multipart([a, msg], flags=zmq.NOBLOCK) except zmq.Again: return False str_m = "{}".format(m) print('{} printing... {}'.format(names[1], str_m[:100])) stackParams = { "name": names[0], "ha": genHa(), "auto": 2, "basedirpath": tdir } alpha = SimpleZStack(stackParams, aHandler, aseed, False) stackParams = { "name": names[1], "ha": genHa(), "auto": 2, "basedirpath": tdir } beta = SimpleZStack(stackParams, bHandler, bseed, True) amotor = SMotor(alpha) looper.add(amotor) bmotor = SMotor(beta) looper.add(bmotor) alpha.connect(name=beta.name, ha=beta.ha, verKeyRaw=beta.verKeyRaw, publicKeyRaw=beta.publicKeyRaw) looper.runFor(0.25) alpha.send({'greetings': 'hi'}, beta.name) looper.runFor(1)
def testSimpleZStacksMsgs(tdir, looper): names = ['Alpha', 'Beta'] genKeys(tdir, names) names = ['Alpha', 'Beta'] aseed = randomSeed() bseed = randomSeed() size = 100000 msg = json.dumps({'random': randomSeed(size).decode()}).encode() def aHandler(m): str_m = "{}".format(m) print('{} printing... {}'.format(names[0], str_m[:100])) d, _ = m print('Message size is {}'.format(len(d['random']))) assert len(d['random']) == size def bHandler(m): print(beta.msgHandler) a = m[1] try: beta.listener.send_multipart([a, msg], flags=zmq.NOBLOCK) except zmq.Again: return False str_m = "{}".format(m) print('{} printing... {}'.format(names[1], str_m[:100])) stackParams = { "name": names[0], "ha": genHa(), "auto": 2, "basedirpath": tdir } alpha = SimpleZStack(stackParams, aHandler, aseed, False) stackParams = { "name": names[1], "ha": genHa(), "auto": 2, "basedirpath": tdir } beta = SimpleZStack(stackParams, bHandler, bseed, True) amotor = SMotor(alpha) looper.add(amotor) bmotor = SMotor(beta) looper.add(bmotor) alpha.connect(name=beta.name, ha=beta.ha, verKeyRaw=beta.verKeyRaw, publicKeyRaw=beta.publicKeyRaw) looper.runFor(0.25) alpha.send({'greetings': 'hi'}, beta.name) looper.runFor(1)
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 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 testNodeRemoveUnknownRemote(allPluginsPath, tdirAndLooper, nodeReg, conf): """ The nodes Alpha and Beta know about each other so they should connect but they should remove remote for C when it tries to connect to them """ tdir, looper = tdirAndLooper names = ["Alpha", "Beta"] logger.debug(names) if conf.UseZStack: _names = names + ['Gamma'] genKeys(tdir, _names + [_ + CLIENT_STACK_SUFFIX for _ in _names]) nrg = {n: nodeReg[n] for n in names} A, B = [ TestNode(name, nrg, basedirpath=tdir, pluginPaths=allPluginsPath) for name in names ] for node in (A, B): looper.add(node) looper.run(checkNodesConnected([A, B])) C = TestNode("Gamma", { **nrg, **{ "Gamma": nodeReg["Gamma"] } }, basedirpath=tdir, pluginPaths=allPluginsPath) looper.add(C) def chk(): assert not C.nodestack.isKeySharing looper.run(eventually(chk, retryWait=2, timeout=22)) stopNodes([ C, ], looper) def chk(): assert C.name not in B.nodestack.nameRemotes assert C.name not in A.nodestack.nameRemotes looper.run(eventually(chk, retryWait=2, timeout=5)) stopNodes([A, B], looper)
def testNodesConnectWhenTheyAllStartAtOnce(allPluginsPath, tdirAndLooper, nodeReg, conf): tdir, looper = tdirAndLooper nodes = [] if conf.UseZStack: names = list(nodeReg.keys()) genKeys(tdir, names + [_ + CLIENT_STACK_SUFFIX for _ in names]) for name in nodeReg: node = TestNode(name, nodeReg, basedirpath=tdir, pluginPaths=allPluginsPath) looper.add(node) nodes.append(node) looper.run(checkNodesConnected(nodes)) stopNodes(nodes, looper)
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(count): 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 = nodeStackClass(stackParams, printer.print, reg) stack.start() stacks.append(stack) if len(stacks) == count: break return stacks
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 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 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
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 testNodesComingUpAtDifferentTimes(allPluginsPath, tdirAndLooper, nodeReg, conf): console = getConsole() console.reinit(flushy=True, verbosity=console.Wordage.verbose) tdir, looper = tdirAndLooper nodes = [] names = list(nodeReg.keys()) if conf.UseZStack: genKeys(tdir, names + [_ + CLIENT_STACK_SUFFIX for _ in names]) shuffle(names) waits = [randint(1, 10) for _ in names] rwaits = [randint(1, 10) for _ in names] for i, name in enumerate(names): node = TestNode(name, nodeReg, basedirpath=tdir, pluginPaths=allPluginsPath) looper.add(node) nodes.append(node) looper.runFor(waits[i]) looper.run(checkNodesConnected(nodes, overrideTimeout=10)) logger.debug("connects") logger.debug("node order: {}".format(names)) logger.debug("waits: {}".format(waits)) stopNodes(nodes, looper) # # Giving some time for sockets to close, use eventually # time.sleep(1) for i, n in enumerate(nodes): n.start(looper.loop) looper.runFor(rwaits[i]) looper.runFor(3) looper.run(checkNodesConnected(nodes, overrideTimeout=10)) stopNodes(nodes, looper) logger.debug("reconnects") logger.debug("node order: {}".format(names)) logger.debug("rwaits: {}".format(rwaits))
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 stacks(tdir, looper, alpha_handler): names = ['Alpha', 'Beta'] genKeys(tdir, names) aseed = randomSeed() bseed = randomSeed() def bHandler(m): msg, a = m beta.send(msg, a) stackParams = { "name": names[0], "ha": genHa(), "auto": 2, "basedirpath": tdir } timer = MockTimer(0) alpha = SimpleZStack(stackParams, alpha_handler.handle, aseed, False, timer=timer) stackParams = { "name": names[1], "ha": genHa(), "auto": 2, "basedirpath": tdir } timer = MockTimer(0) beta = SimpleZStack(stackParams, bHandler, bseed, True, timer=timer) amotor = SMotor(alpha) looper.add(amotor) bmotor = SMotor(beta) looper.add(bmotor) return alpha, beta
def generated_keys(tdir): genKeys(tdir, REGISTRY.keys())