Fabric/Tests/scalability.py

# Copyright 2017-present Open Networking Foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


"""
Check README file
"""

from oftest import config
import logging
import oftest.base_tests as base_tests
import ofp
import os
import time
import json
from oftest.testutils import *
from accton_util import *
from oftest.utils import *
from oftest.ofdpa_utils import *
from accton_util import *

# Number of xconnections created per port
xcon_num = 64

# Number of seconds to wait after switch restart
rest_num = 300

#### Global variable  # defined globally to check whether base_config was executed or not
BASE_RUN = False


#####
##Test cases assumes the ONOS controller is Running and Fabric SWitch is configured to use ONOS as the SDN Controller
## Test cases assumes ONOS controller is in a clean state
## Test cases assumes Fabric switch is in clean state without any flows or group entries from a previous configuration. Its a good idea to reload the Fabric switch before starting the test cases.
## Refer to the test plan for more details

class FabricSW_Scale_Base_TC_0005(base_tests.SimpleDataPlane):
    """
    This Test case defines the base configuration which will serve as a pre-requisite on top of which other test cases are executed.
    """
    ### Read config parameters from JSON file 'global_vars.json'
    ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
    with open(ROOT_DIR + '/' + 'global_vars.json') as f:
        data = json.load(f)

    onos_server_ip = data['onos_server_ip']
    onos_user = data['onos_user']
    onos_passwd = data['onos_passwd']
    switch_ip = data['switch_ip']
    switch_user = data['switch_user']
    switch_passwd = data['switch_passwd']

    def runTest(self):
        global BASE_RUN
        try:
            if len(config[ "port_map" ]) < 4:
                logging.info("Port count less than 4, can't run this case")
                assert False, "Port count less than 4, can't run this case"
                return

            base_config(self)
            onos_flow_group_dump(self)
            switch_flow_group_dump(self)
            time.sleep(2)
            verify_traffic(self)

        finally:
            BASE_RUN = True
            logging.info("End of Test")


class FabricSW_Scale_Base_TC_0010(base_tests.SimpleDataPlane):
    """
    Verify that with scaled up flow configurations, rebooting the switch restores all flows and handles traffic as expected.
    """
    ### Read config parameters from JSON file 'global_vars.json'
    ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
    with open(ROOT_DIR + '/' + 'global_vars.json') as f:
        data = json.load(f)

    switch_ip = data['switch_ip']
    switch_user = data['switch_user']
    switch_passwd = data['switch_passwd']

    def runTest(self):
        global BASE_RUN
        try:
            if len( config[ "port_map" ] ) < 4:
                logging.info( "Port count less than 4, can't run this case")
                assert False, "Port count less than 4, can't run this case"
                return

            if BASE_RUN == False:
                logging.info("Test FabricSW_Scale_Base_TC_0010 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case,"
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0010")
                assert False, "Test FabricSW_Scale_Base_TC_0010 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case," \
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0010"
                return

            # Reboot switch
            logging.info("Restarting switch")
            print("Restarting switch")
            switch_restart(self)
            logging.info("Switch is restarting, wait for 300 secs")
            time.sleep(rest_num)
            logging.info("Switch is restarted")

            #Verify traffic after switch reboot
            logging.info("Verify traffic")
            verify_traffic(self)
            time.sleep(2)

        finally:
            logging.info("End of Test")


class FabricSW_Scale_Base_TC_0015(base_tests.SimpleDataPlane):
    """
    Verify that with scaled up flow configurations, after flapping the data port multiple times the switch restores all flows and handles traffic as expected.
    """
    ### Read config parameters from JSON file 'global_vars.json'
    ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
    with open(ROOT_DIR + '/' + 'global_vars.json') as f:
        data = json.load(f)

    switch_ip = data['switch_ip']
    switch_user = data['switch_user']
    switch_passwd = data['switch_passwd']

    def runTest(self):
        global BASE_RUN
        try:
            if len( config[ "port_map" ] ) < 4:
                logging.info( "Port count less than 4, can't run this case" )
                assert False, "Port count less than 4, can't run this case"
                return

            if BASE_RUN == False:
                logging.info("Test FabricSW_Scale_Base_TC_0015 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case,"
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0015")
                assert False, "Test FabricSW_Scale_Base_TC_0015 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case," \
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0015"
                return

            ports = sorted(config["port_map"].keys())
            # Flap port1 for 100 iterations
            logging.info("Flap port1 for 100 iterations with an interval of '2' seconds")
            for i in range(1, 100):
                switch_port_enable(self, ports[0], False)
                time.sleep(2)
                switch_port_enable(self, ports[0], True)
                time.sleep(2)

            #Verify traffic after port flapping
            logging.info("Verify traffic after port flapping")
            time.sleep(20)
            verify_traffic(self)

        finally:
            logging.info("End of Test")


class FabricSW_Scale_Base_TC_0020(base_tests.SimpleDataPlane):
    """
    Verify that with scaled up flow configurations, after configuring and unconfiguring flows multiple times the switch is stable and handles traffic as expected.
    """

    ### Read config parameters from JSON file 'global_vars.json'
    ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
    with open(ROOT_DIR + '/' + 'global_vars.json') as f:
        data = json.load(f)

    onos_server_ip = data['onos_server_ip']
    onos_user = data['onos_user']
    onos_passwd = data['onos_passwd']
    onos_port = data['onos_port']
    switch_ip = data['switch_ip']
    switch_user = data['switch_user']
    switch_passwd = data['switch_passwd']

    def runTest(self):
        global BASE_RUN
        try:
            if len( config[ "port_map" ] ) < 4:
                logging.info( "Port count less than 4, can't run this case")
                assert False, "Port count less than 4, can't run this case"
                return

            if BASE_RUN == False:
                logging.info("Test FabricSW_Scale_Base_TC_0020 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case,"
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0020")
                assert False, "Test FabricSW_Scale_Base_TC_0020 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case," \
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0020"
                return

            # Un-configure and re-configure of all 'vlan-cross-connect' pairs for 100 iterations with an interval of 5 seconds.
            logging.info("Un-configure and re-configure of all 'vlan-cross-connect' pairs for 100 iterations with an interval of 5 seconds")
            for i in range(1, 100):
                print("Re-create config iteration: ", i)
                logging.info("Re-create config iteration: {}".format(i))
                remove_base_config(self)
                time.sleep(5)
                base_config(self)

            #Verify traffic after config re-creation
            logging.info("Verify traffic after config re-creation")
            time.sleep(2)
            verify_traffic(self)

        finally:
            logging.info("End of Test")


class FabricSW_Scale_Base_TC_0025(base_tests.SimpleDataPlane):
    """
    Verify that with scaled up flow configurations, sending bursts of control traffic (resulting in "Packet_In" messages from switch to controller) the switch is stable and handles traffic as expected.
    """
    ### Read config parameters from JSON file 'global_vars.json'
    ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
    with open(ROOT_DIR + '/' + 'global_vars.json') as f:
        data = json.load(f)

    switch_ip = data['switch_ip']
    switch_user = data['switch_user']
    switch_passwd = data['switch_passwd']
    controller_ip = data['controller_ip']
    controller_port = data['controller_port']
    onos_server_ip = data['onos_server_ip']
    onos_user = data['onos_user']
    onos_passwd = data['onos_passwd']
    onos_port = data['onos_port']

    def runTest(self):
        global BASE_RUN
        try:
            if len( config[ "port_map" ] ) < 4:
                logging.info( "Port count less than 4, can't run this case" )
                assert False, "Port count less than 4, can't run this case"
                return

            if BASE_RUN == False:
                logging.info("Test FabricSW_Scale_Base_TC_0025 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case,"
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0025")
                assert False, "Test FabricSW_Scale_Base_TC_0025 cannot be executed. FabricSW_Scale_Base_TC_0005 is a pre-requisite to this test case," \
                              " Please execute FabricSW_Scale_Base_TC_0005 before FabricSW_Scale_Base_TC_0025"
                return

            # create match
            match = ofp.match()
            match.oxm_list.append(ofp.oxm.eth_type(0x0800))
            match.oxm_list.append(ofp.oxm.ip_proto(1))
            request = ofp.message.flow_add(table_id=60, cookie=42, match=match, instructions=[
                ofp.instruction.apply_actions(actions=[
                    ofp.action.output(port=ofp.OFPP_CONTROLLER, max_len=ofp.OFPCML_NO_BUFFER)]), ],
                                           buffer_id=ofp.OFP_NO_BUFFER, priority=1)
            logging.info("Add an ACL table entry to match ICMP packets and send to controller")
            self.controller.message_send(request)

            # Sent a burst of 64 ICMP packets to data ports 2, 3, and 4.
            logging.info("Sent a burst of 64 ICMP packets to data ports 2, 3, and 4.")
            ports = sorted(config["port_map"].keys())
            # Send ICMP packets to port2
            pair = [ports[0], ports[1]]
            tmp_ports = list(pair)
            tmp_ports.remove(pair[0])
            logging.info("Creating ICMP packets for port2")
            # change dest based on port number
            mac_src = '00:12:34:56:78:%02X' % pair[1]
            parsed_pkt = simple_icmp_packet(eth_src=mac_src)
            pkt = str(parsed_pkt)

            for i in range(64):
                self.dataplane.send(pair[1], pkt)
                print('ICMP to port1 iteration:', i)
                verify_packet_in(self, pkt, ports[1], ofp.OFPR_ACTION)

            # Send ICMP packets to port3
            pair = [ports[0], ports[2]]
            tmp_ports = list(pair)
            tmp_ports.remove(pair[0])
            logging.info("Creating ICMP packets for port3")
            # change dest based on port number
            mac_src = '00:12:34:56:78:%02X' % pair[1]
            parsed_pkt = simple_icmp_packet(eth_src=mac_src)
            pkt = str(parsed_pkt)

            for i in range(64):
                self.dataplane.send(pair[1], pkt)
                print('ICMP to port2 iteration:', i)
                verify_packet_in(self, pkt, ports[2], ofp.OFPR_ACTION)
                # time.sleep(2)

            # Send ICMP packets to port4
            pair = [ports[0], ports[3]]
            tmp_ports = list(pair)
            tmp_ports.remove(pair[0])
            logging.info("Creating ICMP packets for port4")
            # change dest based on port number
            mac_src = '00:12:34:56:78:%02X' % pair[1]
            parsed_pkt = simple_icmp_packet(eth_src=mac_src)
            pkt = str(parsed_pkt)

            for i in range(64):
                self.dataplane.send(pair[1], pkt)
                print('ICMP to port3 iteration: ', i)
                verify_packet_in(self, pkt, ports[3], ofp.OFPR_ACTION)

        finally:
            remove_base_config(self)
            logging.info("End of Test")

def base_config(self):
    ports = (config["port_map"].keys())
    datapathid = get_datapathid(self)
    l = []
    start, end = 101, (101 + xcon_num)
    l.extend(range(start, end))
    # Create flows between port1 and port2
    logging.info("Configure 64 vlan-cross-connect pair between data ports 1 and 2 for vlan101 to vlan164")
    for i in l:
        print('adding xconn port1-2', i)
        add_onos_xconnect(self, datapathid, i, ports[0], ports[1])

    # Create flows between port1 and port3
    logging.info("Configure 64 vlan-cross-connect pair between data ports 1 and 3 for vlan201 to vlan264")
    l = []
    start, end = 201, (201 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        print('adding xconn port1-3', i)
        add_onos_xconnect(self, datapathid, i, ports[0], ports[2])

    # Create flows between port1 and port3
    logging.info("Configure 64 vlan-cross-connect pair between data ports 1 and 4 for vlan301 to vlan364")
    l = []
    start, end = 301, (301 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        print('adding xconn port1-4', i)
        add_onos_xconnect(self, datapathid, i, ports[0], ports[3])


def remove_base_config(self):
    datapathid = get_datapathid(self)
    l = []
    start, end = 101, (101 + xcon_num)
    l.extend(range(start, end))
    # Remove flows vlan101 - vlan164 between ports 1 and 2
    logging.info("Remove flows vlan101 - vlan164 between ports 1 and 2")
    for i in l:
        remove_onos_xconnect(self, datapathid, i)

    #Removeflows vlan201 - vlan264 between ports 1 and 3
    logging.info("Remove flows vlan201 - vlan264 between ports 1 and 3")
    l = []
    start, end = 201, (201 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        remove_onos_xconnect(self, datapathid, i)

    # Remove flows vlan301 - vlan364 between ports 1 and 4
    logging.info("Remove flows vlan301 - vlan364 between ports 1 and 4")
    l = []
    start, end = 301, (301 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        remove_onos_xconnect(self, datapathid, i)


def verify_traffic(self):
    ports = sorted(config["port_map"].keys())

##### Reverse traffic verification. From BNG to OLT" ########
    # # Create and send packets between port1 and port2
    # pair = [ports[0], ports[1]]
    # packets1 = []
    # logging.info("Create double tagged vlan packets with outer vlan IDs 101 - 164 between port1 and port2")
    # # change dest based on port number
    # mac_src = '00:12:34:56:78:%02X' % ports[0]
    # l = []
    # start, end = 101, (101 + xcon_num)
    # l.extend(range(start, end))
    # for i in l:
    #     parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
    #                                             out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
    #                                             eth_dst='00:12:34:56:78:9a', eth_src=mac_src)
    #
    #     pkt = str(parsed_pkt)
    #     packets1.append(pkt)
    #
    # logging.info("Transmit double tagged vlan packets with outer vlan101 - vlan164 to data port1")
    # logging.info("Verify packets are flooded out of data port 2")
    # for i in packets1:
    #     self.dataplane.send(pair[0], i)
    #     print('verify port1-2, xcon: ', (packets1.index(i)+101))
    #     verify_packet(self, i, pair[1])
    #     verify_no_packet(self, i, pair[0])


    # time.sleep(1)

##### Reverse traffic verification. From BNG to OLT" ########
    # # Create and send packets between port1 and port3
    # pair = [ports[0], ports[2]]
    # packets2 = []
    # logging.info("Create double tagged vlan packets with outer vlan IDs 201 - 264 between port1 and port3")
    # # change dest based on port number
    # mac_src = '00:12:34:56:78:%02X' % ports[0]
    # l = []
    # start, end = 201, (201 + xcon_num)
    # l.extend(range(start, end))
    # for i in l:
    #     parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
    #                                             out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
    #                                             eth_dst='00:12:34:56:78:9a', eth_src=mac_src)
    #
    #     pkt = str(parsed_pkt)
    #     packets2.append(pkt)
    #
    # logging.info("Transmit double tagged vlan packets with outer vlan201 - vlan264 to data port1")
    # logging.info("Verify packets are flooded out of data port 3")
    # for i in packets2:
    #     self.dataplane.send(pair[0], i)
    #     # verify traffic
    #     print('verify port1-3, xcon: ', packets2.index(i)+201)
    #     verify_packet(self, i, pair[1])
    #     verify_no_packet(self, i, pair[0])
    #
    # time.sleep(1)

##### Reverse traffic verification. From BNG to OLT" ########
    # Create and send packets between port1 and port4
    # pair = [ports[0], ports[3]]
    # packets3 = []
    # logging.info(
    #     "Create double tagged vlan packets with outer vlan IDs 301 - 364 between port1 and port4")
    # # change dest based on port number
    # mac_src = '00:12:34:56:78:%02X' % pair[0]
    # l = []
    # start, end = 301, (301 + xcon_num)
    # l.extend(range(start, end))
    # for i in l:
    #     parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
    #                                             out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
    #                                             eth_dst='00:12:34:56:78:9a', eth_src=mac_src)
    #
    #     pkt = str(parsed_pkt)
    #     packets3.append(pkt)
    #
    # logging.info("Transmit double tagged vlan packets with outer vlan301 - vlan364 to data port1")
    # logging.info("Verify packets are flooded out of data port 4")
    # for i in packets3:
    #     self.dataplane.send(pair[0], i)
    #     # verify traffic
    #     print('verify port1-4, xcon: ', packets3.index(i)+301)
    #     verify_packet(self, i, pair[1])
    #     verify_no_packet(self, i, pair[0])
    #
    # time.sleep(1)

    # Create and send packets between port2 and port1
    pair = [ports[0], ports[1]]
    packets1 = []
    logging.info("Create double tagged vlan packets with outer vlan IDs 101 - 164 between port2 and port1")
    # change dest based on port number
    mac_src = '00:12:34:56:78:%02X' % ports[1]
    l = []
    start, end = 101, (101 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
                                                out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
                                                eth_dst='00:12:34:56:78:9a', eth_src=mac_src)

        pkt = str(parsed_pkt)
        packets1.append(pkt)

    logging.info("Transmit double tagged vlan packets with outer vlan101 - vlan164 to data port2")
    logging.info("Verify packets are flooded out of data port 1")
    for i in packets1:
        logging.info("Transmitting packet {}".format(packets1.index(i) + 1))
        self.dataplane.send(pair[1], i)
        # verify traffic
        print('verify port2-1, xcon: ', packets1.index(i)+101)
        verify_packet(self, i, pair[0])
        verify_no_packet(self, i, pair[1])

    time.sleep(1)

# # Create and send packets between port3 and port1
    pair = [ports[0], ports[2]]
    packets2 = []
    logging.info("Create double tagged vlan packets with outer vlan IDs 201 - 264 between port3 and port1")
    # change dest based on port number
    mac_src = '00:12:34:56:78:%02X' % ports[2]
    l = []
    start, end = 201, (201 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
                                                out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
                                                eth_dst='00:12:34:56:78:9a', eth_src=mac_src)

        pkt = str(parsed_pkt)
        packets2.append(pkt)

    logging.info("Transmit double tagged vlan packets with outer vlan101 - vlan164 to data port3")
    logging.info("Verify packets are flooded out of data port 1")
    for i in packets2:
        logging.info("Transmitting packet {}".format(packets2.index(i) + 1))
        self.dataplane.send(pair[1], i)
        # verify traffic
        print('verify port3-1, xcon: ', packets2.index(i)+201)
        verify_packet(self, i, pair[0])
        verify_no_packet(self, i, pair[1])

    time.sleep(1)

    # Create and send packets between port4 and port1
    pair = [ports[0], ports[3]]
    packets3 = []
    logging.info(
        "Create double tagged vlan packets with outer vlan IDs 301 - 364 between port4 and port1")
    # change dest based on port number
    mac_src = '00:12:34:56:78:%02X' % ports[3]
    l = []
    start, end = 301, (301 + xcon_num)
    l.extend(range(start, end))
    for i in l:
        parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True,
                                                out_vlan_vid=i, in_dl_vlan_enable=True, in_vlan_vid=10,
                                                eth_dst='00:12:34:56:78:9a', eth_src=mac_src)

        pkt = str(parsed_pkt)
        packets3.append(pkt)

    logging.info("Transmit double tagged vlan packets with outer vlan101 - vlan164 to data port4")
    logging.info("Verify packets are flooded out of data port 1")
    for i in packets3:
        logging.info("Transmitting packet {}".format(packets3.index(i) + 1))
        self.dataplane.send(pair[1], i)
        # verify traffic
        print('verify port4-1, xcon: ', packets3.index(i)+301)
        verify_packet(self, i, pair[0])
        verify_no_packet(self, i, pair[1])


def get_datapathid(self):
    feature_reply = get_featureReplay(self)
    str_datapath_id_f = "{:016x}".format(feature_reply.datapath_id)
    return str_datapath_id_f

def onos_flow_group_dump(self, logfile_name="ONOS_flow_and_groups_dump.log"):
    # Dump the created flows and groups from ONOS in a separate file
    datapathid = get_datapathid(self)
    log_path = (config["log_dir"])
    log_file = logfile_name
    logging.info(
        "The configured flow and group entries from onos are dumped to " + log_path + '/' + log_file)
    send_command_to_onos_cli(log_file, "flows -s any " + datapathid, self.onos_server_ip, self.onos_user,
                             self.onos_passwd, regexp='onos>')
    send_command_to_onos_cli(log_file, "groups", self.onos_server_ip, self.onos_user, self.onos_passwd, regexp='onos>')


def switch_flow_group_dump(self, logfile_name="Switch_flow_and_groups_dump.log"):
    # Dump the created flows and groups from Openflow Switch in a separate file
    datapathid = get_datapathid(self)
    log_path = (config["log_dir"])
    log_file = logfile_name
    logging.info(
        "The configured flow and group entries from switch are dumped to " + log_path + '/' + log_file)
    send_command_to_switch_cli(log_file, "client_flowtable_dump", self.switch_ip,
                               self.switch_user, self.switch_passwd, regexp='root@localhost:~#')
    send_command_to_switch_cli(log_file, "client_grouptable_dump", self.switch_ip,
                               self.switch_user, self.switch_passwd, regexp='root@localhost:~#')