Beispiel #1
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp80No300 Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        logging.info("Sending Get Config Request ")
        request = message.get_config_request()
        (reply, pkt) = self.controller.transact(request)
        self.assertTrue(reply is not None, "Failed to get any reply")
        self.assertEqual(reply.header.type, ofp.OFPT_GET_CONFIG_REPLY,
                         'Response is not Config Reply')

        old_flags = 0
        old_flags = reply.flags

        logging.info("Sending Set Config Request...")
        req = message.set_config()
        if old_flags != 3:
            req.flags = 3
            new_flags = req.flags
            rv = self.controller.message_send(req)
            self.assertTrue(rv is not None, "Unable to send the message")

            #Send get_config_request -- verify change came into effect
            logging.info("Sending Get Config Request...")
            request = message.get_config_request()

            (rep, pkt) = self.controller.transact(request)
            self.assertTrue(rep is not None, "Failed to get any reply")
            self.assertEqual(rep.header.type, ofp.OFPT_GET_CONFIG_REPLY,
                             'Response is not Config Reply')

            try:
                self.assertEqual(
                    rep.flags, new_flags,
                    "frag flags could not be set expected {0} got {1}".format(
                        new_flags, rep.flags))
            finally:
                logging.info("Reverting the changes")
                req = message.set_config()
                req.flags = old_flags
                rv = None
                rv = self.controller.message_send(req)
                self.assertTrue(rv is not None,
                                " Unable to send the set_config message")

                request = message.get_config_request()
                rep1 = None
                (rep1, pkt) = self.controller.transact(request)
                self.assertTrue(rep1 is not None, "Failed to get a reply")
                self.assertTrue(rep1.header.type == ofp.OFPT_GET_CONFIG_REPLY,
                                'Response is not config Reply')
                self.assertTrue(rep1.flags == old_flags,
                                "Changes could not be reverted")
        else:
            logging.info("The Flag already set to OFPC_FRAG_MASK")
Beispiel #2
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp80No300 Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()


        logging.info("Sending Get Config Request ")
        request = message.get_config_request()
        (reply, pkt) = self.controller.transact(request)
        self.assertTrue(reply is not None, "Failed to get any reply")
        self.assertEqual(reply.header.type, ofp.OFPT_GET_CONFIG_REPLY,'Response is not Config Reply')

        old_flags = 0
        old_flags = reply.flags


        logging.info("Sending Set Config Request...")
        req = message.set_config()
        if old_flags != 3 :
            req.flags = 3
            new_flags = req.flags
            rv=self.controller.message_send(req)
            self.assertTrue(rv is not None,"Unable to send the message")

             #Send get_config_request -- verify change came into effect                                                                                                                                                                      
            logging.info("Sending Get Config Request...")
            request = message.get_config_request()

            (rep, pkt) = self.controller.transact(request)
            self.assertTrue(rep is not None, "Failed to get any reply")
            self.assertEqual(rep.header.type, ofp.OFPT_GET_CONFIG_REPLY,'Response is not Config Reply')

            try :
                self.assertEqual(rep.flags,new_flags, "frag flags could not be set expected {0} got {1}" .format(new_flags, rep.flags))
            finally :
                logging.info("Reverting the changes")
                req=message.set_config()
                req.flags=old_flags
                rv=None
                rv=self.controller.message_send(req)
                self.assertTrue(rv is not None, " Unable to send the set_config message")

                request = message.get_config_request()
                rep1=None
                (rep1, pkt) = self.controller.transact(request)
                self.assertTrue(rep1 is not None, "Failed to get a reply")
                self.assertTrue(rep1.header.type==ofp.OFPT_GET_CONFIG_REPLY, 'Response is not config Reply')
                self.assertTrue(rep1.flags==old_flags, "Changes could not be reverted")
        else :
            logging.info("The Flag already set to OFPC_FRAG_MASK")
Beispiel #3
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp90No20 PacketInSizeMiss Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Clear switch state
        rv = delete_all_flows(self.controller)
        self.assertEqual(rv, 0, "Failed to delete all flows")

        #Send a set_config_request message
        miss_send_len = [0, 32, 64, 100]

        #Grp90No20 and Grp90No30 are tested in a loop
        for bytes in miss_send_len:
            req = message.set_config()
            req.miss_send_len = bytes
            rv = self.controller.message_send(req)
            self.assertTrue(rv is not None, "Unable to send the message")
            sleep(1)

            # Send packet to trigger packet_in event
            pkt = simple_tcp_packet()
            match = parse.packet_to_flow_match(pkt)
            self.assertTrue(match is not None,
                            "Could not generate flow match from pkt")
            match.wildcards = ofp.OFPFW_ALL
            match.in_port = of_ports[0]
            self.dataplane.send(of_ports[0], str(pkt))

            #Verify packet_in generated
            (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN,
                                                   timeout=3)
            self.assertTrue(response is not None,
                            'Packet In not received on control plane')
            self.assertEqual(
                response.reason, ofp.OFPR_NO_MATCH,
                'PacketIn received for reason other than OFPR_NO_MATCH. Reason was {0}.'
                .format(response.reason))

            #Verify buffer_id field and data field
            if response.buffer_id == 0xFFFFFFFF:
                self.assertTrue(
                    len(response.data) == len(str(pkt)),
                    "buffer_id of packet_in is -1, however data field of packet_in was the wrong size. Expected {0}, but received {1}"
                    .format(len(str(pkt)), len(response.data)))
            elif (bytes == 0):
                self.assertEqual(
                    len(response.data), bytes,
                    "PacketIn Size is not equal to miss_send_len")
            else:
                self.assertTrue(
                    len(response.data) >= bytes,
                    "PacketIn Size is not atleast miss_send_len bytes")
Beispiel #4
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp90No10 PacketInBodyMiss Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Clear switch state
        rv = delete_all_flows(self.controller)
        self.assertEqual(rv, 0, "Failed to delete all flows")

        #Set miss_send_len field
        logging.info("Sending  set_config_request to set miss_send_len... ")
        req = message.set_config()
        req.miss_send_len = 65535
        rv = self.controller.message_send(req)
        self.assertTrue(rv is not None, "Unable to send the message")
        sleep(1)

        # Send packet to trigger packet_in event
        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        self.assertTrue(match is not None,
                        "Could not generate flow match from pkt")
        match.wildcards = ofp.OFPFW_ALL
        match.in_port = of_ports[0]
        self.dataplane.send(of_ports[0], str(pkt))

        #Verify packet_in generated
        (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, timeout=3)
        self.assertTrue(response is not None,
                        'Packet In not received on control plane')

        #Grp90No50
        #Verify Frame Total Length Field in Packet_in
        self.assertEqual(response.total_len, len(str(pkt)),
                         "PacketIn total_len field is incorrect")

        #Grp90No40
        #Verify in_port field in Packet_in
        self.assertEqual(
            response.in_port, of_ports[0],
            "PacketIn in_port or recieved port field is incorrect")

        #Verify the reason field in Packet_in is OFPR_NO_MATCH
        self.assertEqual(response.reason, ofp.OFPR_NO_MATCH,
                         "PacketIn reason field is incorrect")

        #Verify data field
        self.assertTrue(
            len(response.data) == len(str(pkt)),
            "Complete Data packet was not sent")
Beispiel #5
0
    def runTest(self):

        logging.info("Running SetConfigRequest Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Send get_config_request -- retrive miss_send_len field
        logging.info("Sending Get Config Request ")
        request = message.get_config_request()
        (reply, pkt) = self.controller.transact(request)
        self.assertTrue(reply is not None, "Failed to get any reply")
        self.assertEqual(reply.header.type, ofp.OFPT_GET_CONFIG_REPLY,'Response is not Config Reply')

        miss_send_len = 0
        miss_send_len = reply.miss_send_len
        old_flags = 0 
        old_flags = reply.flags

        #Send set_config_request --- set a different miss_sen_len field and flag
        logging.info("Sending Set Config Request...")
        req = message.set_config()
        
        if miss_send_len < 65400 :# Max miss_send len is 65535
            req.miss_send_len = miss_send_len + 100
            new_miss_send_len = req.miss_send_len
        else :
            req.miss_send_len = miss_send_len - 100
            new_miss_send_len = req.miss_send_len
        
        if old_flags > 0 :
            req.flags = old_flags-1
            new_flags = req.flags
        else :
            req.flags = old_flags+1 
            new_flags = req.flags

        rv=self.controller.message_send(req)
        self.assertTrue(rv is not None,"Unable to send the message")

        #Send get_config_request -- verify change came into effect
        logging.info("Sending Get Config Request...")
        request = message.get_config_request()

        (rep, pkt) = self.controller.transact(request)
        self.assertTrue(rep is not None, "Failed to get any reply")
        self.assertEqual(rep.header.type, ofp.OFPT_GET_CONFIG_REPLY,'Response is not Config Reply')
        self.assertEqual(rep.miss_send_len,new_miss_send_len, "miss_send_len configuration parameter could not be set")
        self.assertEqual(rep.flags,new_flags, "frag flags could not be set")
Beispiel #6
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp90No10 PacketInBodyMiss Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Clear switch state      
        rv = delete_all_flows(self.controller)
        self.assertEqual(rv, 0, "Failed to delete all flows")

        #Set miss_send_len field 
        logging.info("Sending  set_config_request to set miss_send_len... ")
        req = message.set_config()
        req.miss_send_len = 65535
        rv=self.controller.message_send(req)
        self.assertTrue(rv is not None,"Unable to send the message")
        sleep(1)

        # Send packet to trigger packet_in event
        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        self.assertTrue(match is not None, "Could not generate flow match from pkt")
        match.wildcards=ofp.OFPFW_ALL
        match.in_port = of_ports[0]
        self.dataplane.send(of_ports[0],str(pkt))

        #Verify packet_in generated
        (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, timeout=3)
        self.assertTrue(response is not None,
                        'Packet In not received on control plane')

        #Grp90No50
        #Verify Frame Total Length Field in Packet_in 
        self.assertEqual(response.total_len,len(str(pkt)), "PacketIn total_len field is incorrect")

        #Grp90No40
        #Verify in_port field in Packet_in
        self.assertEqual(response.in_port,of_ports[0],"PacketIn in_port or recieved port field is incorrect")

        #Verify the reason field in Packet_in is OFPR_NO_MATCH
        self.assertEqual(response.reason,ofp.OFPR_NO_MATCH,"PacketIn reason field is incorrect")

        #Verify data field 
        self.assertTrue(len(response.data) == len(str(pkt)), "Complete Data packet was not sent")
Beispiel #7
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp80No260 SetConfigRequest Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Send get_config_request -- retrive miss_send_len field
        logging.info("Sending Get Config Request ")
        request = message.get_config_request()
        (reply, pkt) = self.controller.transact(request)
        self.assertTrue(reply is not None, "Failed to get any reply")
        self.assertEqual(reply.header.type, ofp.OFPT_GET_CONFIG_REPLY,
                         'Response is not Config Reply')

        miss_send_len = 0
        miss_send_len = reply.miss_send_len
        old_flags = 0
        old_flags = reply.flags

        #Send set_config_request --- set a different miss_sen_len field and flag
        logging.info("Sending Set Config Request...")
        req = message.set_config()

        if miss_send_len < 65400:  # Max miss_send len is 65535
            req.miss_send_len = miss_send_len + 100
            new_miss_send_len = req.miss_send_len
        else:
            req.miss_send_len = miss_send_len - 100
            new_miss_send_len = req.miss_send_len

        rv = self.controller.message_send(req)
        self.assertTrue(rv is not None, "Unable to send the message")

        #Send get_config_request -- verify change came into effect
        logging.info("Sending Get Config Request...")
        request = message.get_config_request()

        (rep, pkt) = self.controller.transact(request)
        self.assertTrue(rep is not None, "Failed to get any reply")
        self.assertEqual(rep.header.type, ofp.OFPT_GET_CONFIG_REPLY,
                         'Response is not Config Reply')
        self.assertEqual(
            rep.miss_send_len, new_miss_send_len,
            "miss_send_len configuration parameter could not be set")
Beispiel #8
0
    def runTest(self):
        logging = get_logger()
        logging.info("Running Grp90No20 PacketInSizeMiss Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Clear switch state      
        rv = delete_all_flows(self.controller)
        self.assertEqual(rv, 0, "Failed to delete all flows")

        #Send a set_config_request message 
        miss_send_len = [0 ,32 ,64,100]
        
        #Grp90No20 and Grp90No30 are tested in a loop
        for bytes in miss_send_len :
            req = message.set_config()
            req.miss_send_len = bytes
            rv=self.controller.message_send(req)
            self.assertTrue(rv is not None,"Unable to send the message")
            sleep(1)

            # Send packet to trigger packet_in event
            pkt = simple_tcp_packet()
            match = parse.packet_to_flow_match(pkt)
            self.assertTrue(match is not None, "Could not generate flow match from pkt")
            match.wildcards=ofp.OFPFW_ALL
            match.in_port = of_ports[0]
            self.dataplane.send(of_ports[0],str(pkt))

            #Verify packet_in generated
            (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, timeout=3)
            self.assertTrue(response is not None,
                        'Packet In not received on control plane')
            self.assertEqual(response.reason, ofp.OFPR_NO_MATCH, 'PacketIn received for reason other than OFPR_NO_MATCH. Reason was {0}.'.format(response.reason))

            #Verify buffer_id field and data field
            if response.buffer_id == 0xFFFFFFFF:
                self.assertTrue(len(response.data)==len(str(pkt)),"buffer_id of packet_in is -1, however data field of packet_in was the wrong size. Expected {0}, but received {1}".format(len(str(pkt)), len(response.data)))
            elif (bytes==0):
                self.assertEqual(len(response.data),bytes,"PacketIn Size is not equal to miss_send_len") 
            else:
                self.assertTrue(len(response.data)>=bytes,"PacketIn Size is not atleast miss_send_len bytes") 
Beispiel #9
0
    def runTest(self):

        logging.info("Running PacketInSizeMiss Test")
        of_ports = config["port_map"].keys()
        of_ports.sort()

        #Clear switch state      
        rv = delete_all_flows(self.controller)
        self.assertEqual(rv, 0, "Failed to delete all flows")

        #Send a set_config_request message 
        miss_send_len = [0 ,32 ,64,100]
        
        for bytes in miss_send_len :
            req = message.set_config()
            req.miss_send_len = bytes
            rv=self.controller.message_send(req)
            self.assertTrue(rv is not None,"Unable to send the message")
            sleep(1)

            # Send packet to trigger packet_in event
            pkt = simple_tcp_packet()
            match = parse.packet_to_flow_match(pkt)
            self.assertTrue(match is not None, "Could not generate flow match from pkt")
            match.wildcards=ofp.OFPFW_ALL
            match.in_port = of_ports[0]
            self.dataplane.send(of_ports[0],str(pkt))

            #Verify packet_in generated
            (response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, timeout=3)
            self.assertTrue(response is not None,
                        'Packet In not received on control plane')

            #Verify buffer_id field and data field
            if response.buffer_id == 0xFFFFFFFF:
                self.assertTrue(len(response.data)==len(str(pkt)),"Buffer None here but packet_in is not a complete packet")
            elif (bytes==0):
                self.assertEqual(len(response.data),bytes,"PacketIn Size is not equal to miss_send_len") 
            else:
                self.assertTrue(len(response.data)>=bytes,"PacketIn Size is not atleast miss_send_len bytes")