def sendMsg(self):
		self.msgid += 1
		msg = MAGIMessage()
		msg.msgid = self.msgid
		msg.contenttype = MAGIMessage.NONE
		msg.src = "clientnode"
		msg.srcdock = "clientdock"
		msg.dstgroups = ['multicastgroup']
		msg.data = "testing"
		msg._routed = [self.conn.fileno()]
		self.messenger.thread.sendDirect(msg)
		while self.messenger.thread.pollMap[self.conn.fileno()].outmessages:
			time.sleep(0.2) #waiting for message to be sent
	def sendMsg(self):
		self.msgid += 1
		msg = MAGIMessage()
		msg.msgid = self.msgid
		msg.contenttype = MAGIMessage.NONE
		msg.src = "servernode"
		msg.srcdock = "serverdock"
		msg.dstgroups = ['multicastgroup']
		msg.data = "success"
		msg._routed = [self.conn.fileno()]
		self.messenger.thread.sendDirect(msg)
		while self.messenger.thread.pollMap[self.conn.fileno()].outmessages:
			time.sleep(0.2) #waiting for message to be sent
Example #3
0
    def test_GroupAckAggregation(self):
        """ Test aggregation of group acknowledgments """
        self.transports[3] = TestTransport(3)
        self.router.transportAdded(self.transports[3])
        self.neighbors = {0: {}, 1: {}, 2: {}, 3: {}}
        for k in self.transports:
            self.neighbors[k] = defaultdict(set)

        self._incomingGroupAdd(1, 'n11', ['g1', 'g2'])
        self._incomingGroupAdd(1, 'n12', ['g3'])

        self._incomingGroupAdd(2, 'n21', ['g1', 'g2'])
        self._incomingGroupAdd(2, 'n22', ['g1', 'g3'])
        self._checkGroupState()

        # Check the processing of a message with groups that wants an ack, verify data structure inside
        msg = MAGIMessage(src="n30", nodes=["n21"], groups=['g1', 'g3'])
        msg.msgid = 789
        msg.flags |= MAGIMessage.WANTACK
        msg._receivedon = self.transports[3]
        msg._routed = self.router.routeMessage(msg)

        self.assertEqual(msg._routed, set([1, 2]))
        out = self.router.processFWD([msg], time.time())
        self.assertEquals(out, [msg])

        key = ("n30", 789)
        self.assertEquals(self.router.ackHolds.keys(), [key])
        self.assertEquals(sorted(self.router.ackHolds[key].keys()),
                          ['g1', 'g3'])
        self.assertEquals(self.router.ackHolds[key]['g1'][1], set(['n11']))
        self.assertEquals(self.router.ackHolds[key]['g1'][2],
                          set(['n21', 'n22']))
        self.assertEquals(self.router.ackHolds[key]['g3'][1], set(['n12']))
        self.assertEquals(self.router.ackHolds[key]['g3'][2], set(['n22']))
        self.store.outgoing = []  # clear

        # from N11, ack stops here
        ack = msg.createAck("", ['g1'])
        ack._receivedon = self.transports[1]
        ack.src = "n11"
        out = self.router.processFWD(
            [ack], time.time())  # no group routing, only node routing
        self.assertEquals(self.router.ackHolds[key]['g1'].keys(),
                          [2])  # nothing left on transport 1 for g1
        self.assertEquals(0, len(out))

        # from N21, ack passes with n21 but no groups
        ack = msg.createAck("n21", ['g1'])
        ack.src = "n21"
        ack._receivedon = self.transports[2]
        out = self.router.processFWD([ack], time.time())
        self.assertEquals(self.router.ackHolds[key]['g1'][2], set(['n22']))
        self.assertEquals(1, len(out))
        self.assertEquals("n21", out[0].data)

        # from N22, ack passes with g1
        ack = msg.createAck("", ['g1', 'g3'])
        ack.src = "n22"
        ack._receivedon = self.transports[2]
        out = self.router.processFWD([ack], time.time())
        self.assertEquals(self.router.ackHolds[key].keys(),
                          ['g3'])  # g1 complete
        self.assertEquals(self.router.ackHolds[key]['g3'].keys(),
                          [1])  # g3 is still active on transport 1
        self.assertEquals(1, len(out))
        self.assertEquals(",g1", out[0].data)

        # from N12, ack passes with g2
        ack = msg.createAck("", ['g3'])
        ack.src = "n12"
        ack._receivedon = self.transports[1]
        out = self.router.processFWD([ack], time.time())
        self.assertEquals(self.router.ackHolds.keys(), [])  # all complete
        self.assertEquals(1, len(out))
        self.assertEquals(",g3", out[0].data)
Example #4
0
	def test_GroupAckAggregation(self):
		""" Test aggregation of group acknowledgments """
		self.transports[3] = TestTransport(3)
		self.router.transportAdded(self.transports[3])
		self.neighbors = {0: {}, 1: {}, 2: {}, 3: {}}
		for k in self.transports:
			self.neighbors[k] = defaultdict(set)

		self._incomingGroupAdd(1, 'n11', ['g1', 'g2'])
		self._incomingGroupAdd(1, 'n12', ['g3'])

		self._incomingGroupAdd(2, 'n21', ['g1', 'g2'])
		self._incomingGroupAdd(2, 'n22', ['g1', 'g3'])
		self._checkGroupState()

		# Check the processing of a message with groups that wants an ack, verify data structure inside
		msg = MAGIMessage(src="n30", nodes=["n21"], groups=['g1', 'g3'])
		msg.msgid = 789
		msg.flags |= MAGIMessage.WANTACK
		msg._receivedon = self.transports[3]
		msg._routed = self.router.routeMessage(msg)

		self.assertEqual(msg._routed, set([1, 2]))
		out = self.router.processFWD([msg], time.time())
		self.assertEquals(out, [msg])

		key = ("n30", 789)
		self.assertEquals(self.router.ackHolds.keys(), [key])
		self.assertEquals(sorted(self.router.ackHolds[key].keys()),	['g1', 'g3'])
		self.assertEquals(self.router.ackHolds[key]['g1'][1],		set(['n11']))
		self.assertEquals(self.router.ackHolds[key]['g1'][2],		set(['n21', 'n22']))
		self.assertEquals(self.router.ackHolds[key]['g3'][1],		set(['n12']))
		self.assertEquals(self.router.ackHolds[key]['g3'][2],		set(['n22']))
		self.store.outgoing = []  # clear
		
		# from N11, ack stops here
		ack = msg.createAck("", ['g1']) 
		ack._receivedon = self.transports[1]
		ack.src = "n11"
		out = self.router.processFWD([ack], time.time())  # no group routing, only node routing
		self.assertEquals(self.router.ackHolds[key]['g1'].keys(),	[2]) # nothing left on transport 1 for g1
		self.assertEquals(0, len(out))

		# from N21, ack passes with n21 but no groups
		ack = msg.createAck("n21", ['g1']) 
		ack.src = "n21"
		ack._receivedon = self.transports[2]
		out = self.router.processFWD([ack], time.time())
		self.assertEquals(self.router.ackHolds[key]['g1'][2],		set(['n22']))
		self.assertEquals(1, len(out))
		self.assertEquals("n21", out[0].data)

		# from N22, ack passes with g1
		ack = msg.createAck("", ['g1', 'g3']) 
		ack.src = "n22"
		ack._receivedon = self.transports[2]
		out = self.router.processFWD([ack], time.time())
		self.assertEquals(self.router.ackHolds[key].keys(), ['g3'])  # g1 complete
		self.assertEquals(self.router.ackHolds[key]['g3'].keys(), [1]) # g3 is still active on transport 1
		self.assertEquals(1, len(out))
		self.assertEquals(",g1", out[0].data)

		# from N12, ack passes with g2
		ack = msg.createAck("", ['g3']) 
		ack.src = "n12"
		ack._receivedon = self.transports[1]
		out = self.router.processFWD([ack], time.time())
		self.assertEquals(self.router.ackHolds.keys(), [])  # all complete
		self.assertEquals(1, len(out))
		self.assertEquals(",g3", out[0].data)