コード例 #1
0
 def test_Checksum(self):
     """ Verify that checksum is as expected on all platforms and encoding """
     self.assertEqual(listChecksum(["group1", "http2", "web3"]), 809305538)
     self.assertEqual(
         listChecksum(
             ["group1", "http2", "web3", "ftp4", "ssh5", "Harpoon6"]),
         3224243152)
コード例 #2
0
    def test_MultiRoute(self):
        """ Test multiple routes with loopback """
        # from local to g1, no route requests, should deliver out t11 for g1, t12 for g2, not back to local as that was source
        request = {'add': ['g1'], 'count': 1, 'checksum': listChecksum(['g1'])}
        rtmsg1 = MAGIMessage(src="n1",
                             groups=["__NEIGH__"],
                             docks=[GroupRouter.DOCK],
                             data=yaml.safe_dump(request))
        rtmsg1._receivedon = self.transports[11]

        request = {'add': ['g2'], 'count': 1, 'checksum': listChecksum(['g2'])}
        rtmsg2 = MAGIMessage(src="n2",
                             groups=["__NEIGH__"],
                             docks=[GroupRouter.DOCK],
                             data=yaml.safe_dump(request))
        rtmsg2._receivedon = self.transports[12]

        msg = self.newMsg()
        msg.dstnodes = []
        msg._receivedon = self.router.transportMap[0]

        self.router.routers[0].groupRequest(
            GroupRequest("join", "g1", "default"))
        self.push(rtmsg1)
        self.push(rtmsg2)
        self.push(msg)

        self._checkForMessageOnlyIn("dstdocks", ['RouteRequest'], [])
        self._checkForMessageOnlyIn("msgid", 1234, [11, 12])
        self.assertEquals(
            self.router.rxqueue.qsize(), 1,
            "Local receive queue should have an incoming message")
        self.commonAssert()
コード例 #3
0
	def test_remoteGroup(self):
		""" Test message with a remote group and transport down """
		addother = { 'add': ['othergroup'], 'count': 1, 'checksum': listChecksum(['othergroup']) }
		rtmsg1 = MAGIMessage(groups=[GroupRouter.ONEHOPNODES], contenttype=MAGIMessage.YAML, docks=[GroupRouter.DOCK], data=yaml.safe_dump(addother))
		rtmsg1._receivedon = self.transports[2]

		adddead = { 'add': ['deadgroup'], 'count': 2, 'checksum': listChecksum(['deadgroup', 'othergroup']) }
		rtmsg2 = MAGIMessage(groups=[GroupRouter.ONEHOPNODES], contenttype=MAGIMessage.YAML, docks=[GroupRouter.DOCK], data=yaml.safe_dump(adddead))
		rtmsg2._receivedon = self.transports[2]

		msg = MAGIMessage(groups=["othergroup"])
		msg._receivedon = self.transports[1]
 
		# Local joins mygroup, on transport2 they join othergroup and deadgroup, message enters on transport1 for othergroup
		self.router.groupRequest(GroupRequest("join", "mygroup", "default"))
		self.router.processIN([rtmsg1], time.time())
		self.router.processIN([rtmsg2], time.time())
		fds = self.router.routeMessage(msg)
		self.assertEqual(fds, set([2]))

		# Now transport is flagged as down, same message should route to nowhere
		self.router.transportRemoved(2, self.transports[2])
		msg._appendedto = set()
		fds = self.router.routeMessage(msg)
		self.assertEqual(fds, set())
コード例 #4
0
    def test_DoubleSend(self):
        """ Test for no routing out same interface twice for paused messages """
        # from n1 to n2,g1, route requests on local, should deliver out t11 for g1,  and then out t11 again for n1 but be squelched
        msg = self.newMsg()
        msg.dstnodes = ['n2']
        msg._receivedon = self.router.transportMap[0]

        request = {'add': ['g1'], 'count': 1, 'checksum': listChecksum(['g1'])}
        rtmsg1 = MAGIMessage(src="ignore",
                             groups=["__NEIGH__"],
                             docks=[GroupRouter.DOCK],
                             data=yaml.safe_dump(request))
        rtmsg1._receivedon = self.transports[11]

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

        self.push(rtmsg1)
        self.push(msg)
        self.push(rtmsg2)

        self._checkForMessageOnlyIn("data", yaml.safe_dump({'request': 'n2'}),
                                    [10, 11, 12])
        self._checkForMessageOnlyIn("msgid", 1234, [11])
        msgcount = len(self.transports[11].outmessages)
        self.assert_(
            msgcount == 2,
            "Should only be 1 request and 1 message in t11 queue, found %d" %
            msgcount)
        self.assert_(self.router.rxqueue.empty(),
                     "Local receive queue should be empty")
        self.commonAssert()
コード例 #5
0
 def _incomingGroupList(self, fd, src, grouplist):
     self.neighbors[fd][src] = set(grouplist)
     request = {
         'set': grouplist,
         'count': len(self.neighbors[fd][src]),
         'checksum': listChecksum(self.neighbors[fd][src])
     }
     msg = MAGIMessage(src=src,
                       contenttype=MAGIMessage.YAML,
                       docks=[GroupRouter.DOCK],
                       data=yaml.safe_dump(request))
     msg._receivedon = self.transports[fd]
     self.router.processIN([msg], time.time())
コード例 #6
0
    def test_remoteGroup(self):
        """ Test message with a remote group and transport down """
        addother = {
            'add': ['othergroup'],
            'count': 1,
            'checksum': listChecksum(['othergroup'])
        }
        rtmsg1 = MAGIMessage(groups=[GroupRouter.ONEHOPNODES],
                             contenttype=MAGIMessage.YAML,
                             docks=[GroupRouter.DOCK],
                             data=yaml.safe_dump(addother))
        rtmsg1._receivedon = self.transports[2]

        adddead = {
            'add': ['deadgroup'],
            'count': 2,
            'checksum': listChecksum(['deadgroup', 'othergroup'])
        }
        rtmsg2 = MAGIMessage(groups=[GroupRouter.ONEHOPNODES],
                             contenttype=MAGIMessage.YAML,
                             docks=[GroupRouter.DOCK],
                             data=yaml.safe_dump(adddead))
        rtmsg2._receivedon = self.transports[2]

        msg = MAGIMessage(groups=["othergroup"])
        msg._receivedon = self.transports[1]

        # Local joins mygroup, on transport2 they join othergroup and deadgroup, message enters on transport1 for othergroup
        self.router.groupRequest(GroupRequest("join", "mygroup", "default"))
        self.router.processIN([rtmsg1], time.time())
        self.router.processIN([rtmsg2], time.time())
        fds = self.router.routeMessage(msg)
        self.assertEqual(fds, set([2]))

        # Now transport is flagged as down, same message should route to nowhere
        self.router.transportRemoved(2, self.transports[2])
        msg._appendedto = set()
        fds = self.router.routeMessage(msg)
        self.assertEqual(fds, set())
コード例 #7
0
ファイル: 021_routerTest.py プロジェクト: deter-project/magi
	def test_MultiRoute(self):
		""" Test multiple routes with loopback """
		# from local to g1, no route requests, should deliver out t11 for g1, t12 for g2, not back to local as that was source
		request = { 'add': ['g1'], 'count': 1, 'checksum': listChecksum(['g1']) }
		rtmsg1 = MAGIMessage(src="n1", groups=["__NEIGH__"], docks=[GroupRouter.DOCK], data=yaml.safe_dump(request))
		rtmsg1._receivedon = self.transports[11]

		request = { 'add': ['g2'], 'count': 1, 'checksum': listChecksum(['g2']) }
		rtmsg2 = MAGIMessage(src="n2", groups=["__NEIGH__"], docks=[GroupRouter.DOCK], data=yaml.safe_dump(request))
		rtmsg2._receivedon = self.transports[12]

		msg = self.newMsg()
		msg.dstnodes = []
		msg._receivedon = self.router.transportMap[0]

		self.router.routers[0].groupRequest(GroupRequest("join", "g1", "default"))
		self.push(rtmsg1)
		self.push(rtmsg2)
		self.push(msg)

		self._checkForMessageOnlyIn("dstdocks", ['RouteRequest'], [])
		self._checkForMessageOnlyIn("msgid", 1234, [11, 12])
		self.assertEquals(self.router.rxqueue.qsize(), 1, "Local receive queue should have an incoming message")
		self.commonAssert()
コード例 #8
0
ファイル: 021_routerTest.py プロジェクト: deter-project/magi
	def test_DoubleSend(self):
		""" Test for no routing out same interface twice for paused messages """
		# from n1 to n2,g1, route requests on local, should deliver out t11 for g1,  and then out t11 again for n1 but be squelched
		msg = self.newMsg()
		msg.dstnodes = ['n2']
		msg._receivedon = self.router.transportMap[0]

		request = { 'add': ['g1'], 'count': 1, 'checksum': listChecksum(['g1']) }
		rtmsg1 = MAGIMessage(src="ignore", groups=["__NEIGH__"], docks=[GroupRouter.DOCK], data=yaml.safe_dump(request))
		rtmsg1._receivedon = self.transports[11]

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

		self.push(rtmsg1)
		self.push(msg)
		self.push(rtmsg2)

		self._checkForMessageOnlyIn("data", yaml.safe_dump({'request':'n2'}), [10, 11, 12])
		self._checkForMessageOnlyIn("msgid", 1234, [11])
		msgcount = len(self.transports[11].outmessages)
		self.assert_(msgcount == 2, "Should only be 1 request and 1 message in t11 queue, found %d" % msgcount)
		self.assert_(self.router.rxqueue.empty(), "Local receive queue should be empty")
		self.commonAssert()
コード例 #9
0
	def _incomingGroupList(self, fd, src, grouplist):
		self.neighbors[fd][src] = set(grouplist)
		request = { 'set': grouplist, 'count': len(self.neighbors[fd][src]), 'checksum': listChecksum(self.neighbors[fd][src]) }
		msg = MAGIMessage(src=src, contenttype=MAGIMessage.YAML, docks=[GroupRouter.DOCK], data=yaml.safe_dump(request))
		msg._receivedon = self.transports[fd]
		self.router.processIN([msg], time.time())
コード例 #10
0
	def test_Checksum(self):
		""" Verify that checksum is as expected on all platforms and encoding """
		self.assertEqual(listChecksum(["group1", "http2", "web3"]), 809305538)
		self.assertEqual(listChecksum(["group1", "http2", "web3", "ftp4", "ssh5", "Harpoon6"]), 3224243152)