class TestStateChange(unittest.TestCase):
    def setUp(self):
        self.api = SciPass(
            logger=logging.getLogger(__name__),
            config=str(os.getcwd()) + "/t/etc/SciPass_balancer_only.xml",
            readState=False,
        )
        self.datapath = Mock(id=1)
        self.api.switchJoined(self.datapath)
        self.state = "/var/run/" + "%016x" % self.datapath.id + "IUPUI" + ".json"

    def tearDown(self):
        os.remove(self.state)

    def test_initial_config(self):
        assert os.path.isfile(self.state) == 1
        with open(self.state) as data_file:
            data = json.load(data_file)
        data = data[0]
        switches = data["switch"].keys()
        assert switches[0] == "%016x" % self.datapath.id
        domain = data["switch"]["%016x" % self.datapath.id]["domain"].keys()
        assert domain[0] == "IUPUI"
        mode = data["switch"]["%016x" % self.datapath.id]["domain"][domain[0]]["mode"].keys()
        assert mode[0] == "Balancer"

    def test_state_restore(self):
        net1 = ipaddr.IPv4Network("192.168.0.0/24")
        group = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixGroup(net1)
        res = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").splitSensorPrefix(group, net1, check=False)
        self.assertTrue(res == 1)
        net2 = ipaddr.IPv6Network("2001:0DB8::/48")
        group = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixGroup(net2)
        res = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").splitSensorPrefix(group, net2, check=False)
        self.assertTrue(res == 1)
        self.api.switchLeave(self.datapath)
        time.sleep(3)
        self.api = SciPass(
            logger=logging.getLogger(__name__),
            config=str(os.getcwd()) + "/t/etc/SciPass_balancer_only.xml",
            readState=True,
        )
        self.api.switchJoined(self.datapath)
        prefixes = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixes()
        prefixList = prefixes.keys()
        assert net1 not in prefixList
        assert net2 not in prefixList
        net = [ipaddr.IPv4Network("192.168.0.0/25"), ipaddr.IPv4Network("192.168.0.128/25")]
        assert (n in prefixList for n in net)
        net = [ipaddr.IPv6Network("2001:db8::/49"), ipaddr.IPv6Network("2001:db8:0:8000::/49")]
        assert (n in prefixList for n in net)
Beispiel #2
0
class TestStateChange(unittest.TestCase):
    
    def setUp(self):
        self.api = SciPass( logger = logging.getLogger(__name__),
                            config = str(os.getcwd()) + "/t/etc/SciPass_balancer_only.xml", 
                            readState = False)
        self.datapath = Mock(id=1)
        self.api.switchJoined(self.datapath)
        self.state = "/var/run/" + "%016x" % self.datapath.id +  "IUPUI" + ".json"

    def tearDown(self):
        os.remove(self.state)                                                                                                                  
        

    def test_initial_config(self):
        assert(os.path.isfile(self.state) == 1)
        with open(self.state) as data_file:
            data = json.load(data_file)
        data = data[0]
        switches = data["switch"].keys()
        assert(switches[0] == "%016x" % self.datapath.id)
        domain = data["switch"]["%016x" % self.datapath.id]["domain"].keys()
        assert(domain[0] == "IUPUI")
        mode = data["switch"]["%016x" % self.datapath.id]["domain"][domain[0]]["mode"].keys()
        assert(mode[0] == "Balancer")
                 
    def test_state_restore(self):
        net1 = ipaddr.IPv4Network("192.168.0.0/24")
        group = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixGroup(net1)
        res = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").splitSensorPrefix(group,net1,check=False)
        self.assertTrue(res == 1)
        net2 = ipaddr.IPv6Network("2001:0DB8::/48")
        group = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixGroup(net2)
        res = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").splitSensorPrefix(group,net2,check=False)
        self.assertTrue(res == 1)
        self.api.switchLeave(self.datapath)
        time.sleep(3)
        self.api = SciPass( logger = logging.getLogger(__name__),
                            config = str(os.getcwd()) + "/t/etc/SciPass_balancer_only.xml",
                            readState = True)
        self.api.switchJoined(self.datapath)
        prefixes = self.api.getBalancer("%016x" % self.datapath.id, "IUPUI").getPrefixes()
        prefixList = prefixes.keys()
        assert(net1 not in prefixList)
        assert(net2 not in prefixList)
        net  = [ipaddr.IPv4Network('192.168.0.0/25'), ipaddr.IPv4Network('192.168.0.128/25')]
        assert(n in prefixList for n in net)
        net = [ipaddr.IPv6Network('2001:db8::/49'), ipaddr.IPv6Network('2001:db8:0:8000::/49')]
        assert(n in prefixList for n in net)
Beispiel #3
0
class TestFunctionality(unittest.TestCase):
    def setUp(self):
        self.api = SciPass( logger = logging.getLogger(__name__),
                          config = str(os.getcwd()) + "/t/etc/SciPass.xml" )
        
    def test_update_prefix_bw(self):
        #first setup the handler to get all the flows that were sent
        flows = []
        def flowSent(dpid = None, header = None, actions = None,command = None, priority = None, idle_timeout = None, hard_timeout = None):
            flows.append({'dpid': dpid, 'header': header, 'actions': actions, 'command': command, 'priority': priority, 'idle_timeout': idle_timeout, 'hard_timeout': hard_timeout})

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)

        self.assertEquals( len(flows), 25)
        self.api.updatePrefixBW("%016x" % datapath.id, ipaddr.IPv4Network("10.0.19.0/24"), 500,500)
        self.assertTrue(self.api.getBalancer("%016x" % datapath.id, "R&E").getPrefixBW(ipaddr.IPv4Network("10.0.19.0/24")), 1000)
        self.api.updatePrefixBW("%016x" % datapath.id, ipaddr.IPv4Network("10.0.17.0/24"), 500,500)
        self.assertTrue(self.api.getBalancer("%016x" % datapath.id, "R&E").getPrefixBW(ipaddr.IPv4Network("10.0.17.0/24")), 1000)
        

    def test_good_flow(self):
        flows = []
        def flowSent(dpid = None, header = None, actions = None,command = None, priority = None, idle_timeout = None, hard_timeout = None):
            flows.append({'dpid': dpid, 'header': header, 'actions': actions, 'command': command, 'priority': priority, 'idle_timeout': idle_timeout, 'hard_timeout': hard_timeout})

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)
        #self.logger.error("testing good flow")
        self.assertEquals(len(flows),25)
        flows = []
        self.api.good_flow({"nw_src": "10.0.20.2/32", "nw_dst":"156.56.6.1/32", "tp_src":1, "tp_dst":2})
        self.assertEquals(len(flows),2)
        flow = flows[0]
        self.assertEqual(int(flow['hard_timeout']),0)
        self.assertEqual(int(flow['idle_timeout']),90)
        self.assertEqual(flow['actions'],[{'type': 'output', 'port': '10'}])
        self.assertEqual(flow['header'],{'phys_port': 2, 'nw_src_mask': 32, 'nw_dst_mask': 32, 'nw_src': 167777282, 'tp_dst': 2, 'tp_src': 1, 'nw_dst': 2620917249})
        self.assertEqual(int(flow['priority']),65535)
        self.assertEqual(flow['command'],"ADD")
        self.assertEqual(flow['dpid'],"%016x" % datapath.id)
        flow = flows[1]
        self.assertEqual(int(flow['hard_timeout']),0)
        self.assertEqual(int(flow['idle_timeout']),90)
        self.assertEqual(flow['actions'],[{'type': 'output', 'port': '2'}])
        self.assertEqual(flow['header'],{'phys_port': 10, 'nw_src_mask': 32, 'nw_dst_mask': 32, 'nw_dst': 167777282, 'tp_dst': 1, 'tp_src': 2, 'nw_src': 2620917249})
        self.assertEqual(int(flow['priority']),65535)
        self.assertEqual(flow['command'],"ADD")
        self.assertEqual(flow['dpid'],"%016x" % datapath.id)
        
        

    def test_bad_flow(self):
        flows = []
        def flowSent(dpid = None, header = None, actions = None,command = None, priority = None, idle_timeout = None, hard_timeout = None):
            flows.append({'dpid': dpid, 'header': header, 'actions': actions, 'command': command, 'priority': priority, 'idle_timeout': idle_timeout, 'hard_timeout': hard_timeout})

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)
        #self.logger.error("testing good flow")
        self.assertEquals(len(flows),25)
        flows = []
        self.api.bad_flow({"nw_src": "10.0.20.2/32", "nw_dst":"156.56.6.1/32", "tp_src":1, "tp_dst":2})
        self.assertEquals(len(flows),2)
        print flows[0]
        print flows[1]
        flow = flows[0]
        self.assertEqual(int(flow['hard_timeout']),0)
        self.assertEqual(int(flow['idle_timeout']),90)
        self.assertEqual(flow['actions'],[])
        self.assertEqual(flow['header'],{'phys_port': 2, 'nw_src_mask': 32, 'nw_dst_mask': 32, 'nw_src': 167777282, 'tp_dst': 2, 'tp_src': 1, 'nw_dst': 2620917249})
        self.assertEqual(int(flow['priority']),65535)
        self.assertEqual(flow['command'],"ADD")
        self.assertEqual(flow['dpid'],"%016x" % datapath.id)
        flow = flows[1]
        self.assertEqual(int(flow['hard_timeout']),0)
        self.assertEqual(int(flow['idle_timeout']),90)
        self.assertEqual(flow['actions'],[])
        self.assertEqual(flow['header'],{'phys_port': 10, 'nw_src_mask': 32, 'nw_dst_mask': 32, 'nw_dst': 167777282, 'tp_dst': 1, 'tp_src': 2, 'nw_src': 2620917249})
        self.assertEqual(int(flow['priority']),65535)
        self.assertEqual(flow['command'],"ADD")
        self.assertEqual(flow['dpid'],"%016x" % datapath.id)

    def test_block_unknown_prefix(self):
        pass
    
    def test_bypass_unknown_prefix(self):
        pass       
Beispiel #4
0
class TestFunctionality(unittest.TestCase):
    def setUp(self):
        self.api = SciPass(logger=logging.getLogger(__name__),
                           config=str(os.getcwd()) + "/t/etc/SciPass.xml")

    def test_update_prefix_bw(self):
        #first setup the handler to get all the flows that were sent
        flows = []

        def flowSent(dpid=None,
                     domain=None,
                     header=None,
                     actions=None,
                     command=None,
                     priority=None,
                     idle_timeout=None,
                     hard_timeout=None):
            flows.append({
                'dpid': dpid,
                'header': header,
                'actions': actions,
                'command': command,
                'priority': priority,
                'idle_timeout': idle_timeout,
                'hard_timeout': hard_timeout
            })

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)

        self.assertEquals(len(flows), 25)
        self.api.updatePrefixBW("%016x" % datapath.id,
                                ipaddr.IPv4Network("10.0.19.0/24"), 500, 500)
        self.assertTrue(
            self.api.getBalancer("%016x" % datapath.id, "R&E").getPrefixBW(
                ipaddr.IPv4Network("10.0.19.0/24")), 1000)
        self.api.updatePrefixBW("%016x" % datapath.id,
                                ipaddr.IPv4Network("10.0.17.0/24"), 500, 500)
        self.assertTrue(
            self.api.getBalancer("%016x" % datapath.id, "R&E").getPrefixBW(
                ipaddr.IPv4Network("10.0.17.0/24")), 1000)
        self.api.updatePrefixBW("%016x" % datapath.id,
                                ipaddr.IPv6Network("2001:0DB8::/48"), 500, 500)
        self.assertTrue(
            self.api.getBalancer("%016x" % datapath.id, "R&E").getPrefixBW(
                ipaddr.IPv6Network("2001:0DB8::/48")), 1000)

    def test_good_flow(self):
        flows = []

        def flowSent(dpid=None,
                     domain=None,
                     header=None,
                     actions=None,
                     command=None,
                     priority=None,
                     idle_timeout=None,
                     hard_timeout=None):
            flows.append({
                'dpid': dpid,
                'header': header,
                'actions': actions,
                'command': command,
                'priority': priority,
                'idle_timeout': idle_timeout,
                'hard_timeout': hard_timeout
            })

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)
        #self.logger.error("testing good flow")
        self.assertEquals(len(flows), 25)
        flows = []
        self.api.good_flow({
            "nw_src": "10.0.20.2/32",
            "nw_dst": "156.56.6.1/32",
            "tp_src": 1,
            "tp_dst": 2
        })
        self.assertEquals(len(flows), 2)
        flow = flows[0]
        self.assertEqual(int(flow['hard_timeout']), 0)
        self.assertEqual(int(flow['idle_timeout']), 90)
        self.assertEqual(flow['actions'], [{'type': 'output', 'port': '10'}])
        self.assertEqual(
            flow['header'], {
                'phys_port': 2,
                'nw_src': ipaddr.IPv4Network('10.0.20.2/32'),
                'tp_dst': 2,
                'tp_src': 1,
                'nw_dst': ipaddr.IPv4Network('156.56.6.1/32')
            })
        self.assertEqual(int(flow['priority']), 65535)
        self.assertEqual(flow['command'], "ADD")
        self.assertEqual(flow['dpid'], "%016x" % datapath.id)
        flow = flows[1]
        self.assertEqual(int(flow['hard_timeout']), 0)
        self.assertEqual(int(flow['idle_timeout']), 90)
        self.assertEqual(flow['actions'], [{'type': 'output', 'port': '2'}])
        self.assertEqual(
            flow['header'], {
                'phys_port': 10,
                'nw_dst': ipaddr.IPv4Network('10.0.20.2/32'),
                'tp_dst': 1,
                'tp_src': 2,
                'nw_src': ipaddr.IPv4Network('156.56.6.1/32')
            })
        self.assertEqual(int(flow['priority']), 65535)
        self.assertEqual(flow['command'], "ADD")
        self.assertEqual(flow['dpid'], "%016x" % datapath.id)

    def test_bad_flow(self):
        flows = []

        def flowSent(dpid=None,
                     domain=None,
                     header=None,
                     actions=None,
                     command=None,
                     priority=None,
                     idle_timeout=None,
                     hard_timeout=None):
            flows.append({
                'dpid': dpid,
                'header': header,
                'actions': actions,
                'command': command,
                'priority': priority,
                'idle_timeout': idle_timeout,
                'hard_timeout': hard_timeout
            })

        self.api.registerForwardingStateChangeHandler(flowSent)
        datapath = Mock(id=1)
        self.api.switchJoined(datapath)
        #self.logger.error("testing good flow")
        self.assertEquals(len(flows), 25)
        flows = []
        self.api.bad_flow({
            "nw_src": "10.0.20.2/32",
            "nw_dst": "156.56.6.1/32",
            "tp_src": 1,
            "tp_dst": 2
        })
        self.assertEquals(len(flows), 2)
        print flows[0]
        print flows[1]
        flow = flows[0]
        self.assertEqual(int(flow['hard_timeout']), 0)
        self.assertEqual(int(flow['idle_timeout']), 90)
        self.assertEqual(flow['actions'], [])
        self.assertEqual(
            flow['header'], {
                'phys_port': 2,
                'nw_src': ipaddr.IPv4Network('10.0.20.2/32'),
                'tp_dst': 2,
                'tp_src': 1,
                'nw_dst': ipaddr.IPv4Network('156.56.6.1/32')
            })
        self.assertEqual(int(flow['priority']), 65535)
        self.assertEqual(flow['command'], "ADD")
        self.assertEqual(flow['dpid'], "%016x" % datapath.id)
        flow = flows[1]
        self.assertEqual(int(flow['hard_timeout']), 0)
        self.assertEqual(int(flow['idle_timeout']), 90)
        self.assertEqual(flow['actions'], [])
        self.assertEqual(
            flow['header'], {
                'phys_port': 10,
                'nw_dst': ipaddr.IPv4Network('10.0.20.2/32'),
                'tp_dst': 1,
                'tp_src': 2,
                'nw_src': ipaddr.IPv4Network('156.56.6.1/32')
            })
        self.assertEqual(int(flow['priority']), 65535)
        self.assertEqual(flow['command'], "ADD")
        self.assertEqual(flow['dpid'], "%016x" % datapath.id)

    def test_block_unknown_prefix(self):
        pass

    def test_bypass_unknown_prefix(self):
        pass