Example #1
0
    def test_encodeAndDecode(self):
        """ Test encoding and decoding of a message header """
        msg = MAGIMessage()
        msg.msgid = 1234
        msg.flags = 0x63
        msg.contenttype = MAGIMessage.YAML
        msg.src = "mynode"
        msg.srcdock = "sourcedock"
        msg.hmac = "123456789"
        msg.dstnodes = set(['n1', 'n2'])
        msg.dstgroups = set(['g1', 'g2'])
        msg.dstdocks = set(['d1', 'd2'])
        msg.sequence = 98765
        msg.timestamp = 12347890
        msg.data = None

        codec = DefaultCodec()

        hdr = codec.encode(msg)
        ret, hdrsize = codec.decode(hdr)
        ret.data = None

        self.assertEquals(hdrsize, len(hdr))

        for k, v in msg.__dict__.iteritems():
            if k[0] == '_':
                continue
            self.assertEquals(getattr(ret, k), v)
	def test_encodeAndDecode(self):
		""" Test encoding and decoding of a message header """
		msg = MAGIMessage()
		msg.msgid = 1234
		msg.flags = 0x63
		msg.contenttype = MAGIMessage.YAML
		msg.src = "mynode"
		msg.srcdock = "sourcedock"
		msg.hmac = "123456789"
		msg.dstnodes = set(['n1', 'n2'])
		msg.dstgroups = set(['g1', 'g2'])
		msg.dstdocks = set(['d1', 'd2'])
		msg.sequence = 98765
		msg.timestamp = 12347890
		msg.data = None

		codec = DefaultCodec()

		hdr = codec.encode(msg)
		ret, hdrsize = codec.decode(hdr)
		ret.data = None
		
		self.assertEquals(hdrsize, len(hdr))

		for k, v in msg.__dict__.iteritems():
			if k[0] == '_':
				continue
			self.assertEquals(getattr(ret, k), v)
	def addMsg(self, msgid):
		self.msgid += 1
		msg = MAGIMessage()
		msg.msgid = self.msgid
		msg.contenttype = MAGIMessage.NONE
		msg.src = "mynode"
		msg.srcdock = "sourcedock"
		msg.dstgroups = ['g1']
		msg.data = None
		self.mct.processPacket('192.168.1.1', 18808, MCTHeader.PktData(msgid, 1, 1).encode() + self.msgcodec.encode(msg))
	def addBigMessage(self, mid, count, skip):
		msg = MAGIMessage()
		msg.msgid = 12345
		msg.contenttype = MAGIMessage.NONE
		msg.src = "mynode"
		msg.srcdock = "sourcedock"
		msg.dstgroups = ['g1']
		msg.data = "X" * (((TXMessageTracker.SPLITSIZE-4) * count) - len(self.msgcodec.encode(msg)))
		tracker = TXMessageTracker(msg=msg, multicastid=mid, codec=DefaultCodec())
		for ii in range(1,count+1):
			if ii not in skip:
				self.mct.processPacket('192.168.1.1', 18808, tracker.getPart(ii))
	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
 def addMsg(self, msgid):
     self.msgid += 1
     msg = MAGIMessage()
     msg.msgid = self.msgid
     msg.contenttype = MAGIMessage.NONE
     msg.src = "mynode"
     msg.srcdock = "sourcedock"
     msg.dstgroups = ['g1']
     msg.data = None
     self.mct.processPacket(
         '192.168.1.1', 18808,
         MCTHeader.PktData(msgid, 1, 1).encode() +
         self.msgcodec.encode(msg))
Example #8
0
	def newMsg(self):
		msg = MAGIMessage()
		msg.msgid = 1234
		msg.flags = 0x0
		msg.contenttype = MAGIMessage.YAML
		msg.src = "mynode"
		msg.srcdock = "sourcedock"
		msg.hmac = "123456789"
		msg.dstnodes = ['n1', 'n2']
		msg.dstgroups = ['g1', 'g2']
		msg.dstdocks = ['d1', 'd2']
		msg.sequence = 98765
		msg.timestamp = 12347890
		msg.data = "helloworld"
		return msg
Example #9
0
	def newMsg(self):
		msg = MAGIMessage()
		msg.msgid = 1234
		msg.flags = 0x63
		msg.contenttype = MAGIMessage.YAML
		msg.src = "mynode"
		msg.srcdock = "sourcedock"
		msg.hmac = "123456789"
		msg.dstnodes = set(['n1', 'n2'])
		msg.dstgroups = set(['g1', 'g2'])
		msg.dstdocks = set(['d1', 'd2'])
		msg.sequence = 98765
		msg.timestamp = 12347890
		msg.data = "helloworld"
		return msg
 def addBigMessage(self, mid, count, skip):
     msg = MAGIMessage()
     msg.msgid = 12345
     msg.contenttype = MAGIMessage.NONE
     msg.src = "mynode"
     msg.srcdock = "sourcedock"
     msg.dstgroups = ['g1']
     msg.data = "X" * (((TXMessageTracker.SPLITSIZE - 4) * count) -
                       len(self.msgcodec.encode(msg)))
     tracker = TXMessageTracker(msg=msg,
                                multicastid=mid,
                                codec=DefaultCodec())
     for ii in range(1, count + 1):
         if ii not in skip:
             self.mct.processPacket('192.168.1.1', 18808,
                                    tracker.getPart(ii))
Example #11
0
	def test_routeUnknown(self):
		""" Test route without a destination node  """
		msg = MAGIMessage(src="thesrc", nodes=["unknown"])
		msg.msgid = 12345
		msg._receivedon = self.transports[1]

		rtmsg = MAGIMessage(src="unknown", groups=["__ALL__"], docks=[NodeRouter.DOCK], data=yaml.safe_dump({'response':True}))
		rtmsg._receivedon = self.transports[2]

		# Attempt to route message, should have nowhere to go
		fds = self.router.routeMessage(msg)
		self.assertEqual(fds, set([]))
		self._checkForMessageOnlyIn('data', yaml.safe_dump({'request':'unknown'}), [1, 2])

		# Get a route response and check for proper queing, original header information should stay intact when sending paused
		self.router.processIN([rtmsg], time.time())
		self._checkForMessageOnlyIn('dstnodes', set(['unknown']), [2])
		self._checkForMessageOnlyIn('src', "thesrc", [2])
		self._checkForMessageOnlyIn('msgid', 12345, [2])
Example #12
0
    def test_routeUnknown(self):
        """ Test route without a destination node  """
        msg = MAGIMessage(src="thesrc", nodes=["unknown"])
        msg.msgid = 12345
        msg._receivedon = self.transports[1]

        rtmsg = MAGIMessage(src="unknown",
                            groups=["__ALL__"],
                            docks=[NodeRouter.DOCK],
                            data=yaml.safe_dump({'response': True}))
        rtmsg._receivedon = self.transports[2]

        # Attempt to route message, should have nowhere to go
        fds = self.router.routeMessage(msg)
        self.assertEqual(fds, set([]))
        self._checkForMessageOnlyIn('data',
                                    yaml.safe_dump({'request': 'unknown'}),
                                    [1, 2])

        # Get a route response and check for proper queing, original header information should stay intact when sending paused
        self.router.processIN([rtmsg], time.time())
        self._checkForMessageOnlyIn('dstnodes', set(['unknown']), [2])
        self._checkForMessageOnlyIn('src', "thesrc", [2])
        self._checkForMessageOnlyIn('msgid', 12345, [2])
Example #13
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 #14
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)