olt-complex.py

'''
More complex (composite) test-cases for the OLT
'''

import logging
from oftest.testutils import *
from oltbase import OltBaseTest
from oltconstants import *


class Thing(object):
    """An object we can stash arbitrary attributes for easy reach"""
    def __init__(self, **kws):
        self.__dict__.update(kws)


class EapolInOnly(OltBaseTest):
    def runTest(self):
        self.resetOlt()
        self.installEapolRule()
        self.sendEapolIn()


class EapolOutOnly(OltBaseTest):
    def runTest(self):
        self.resetOlt()
        self.sendEapolOut()


class ControllerAccess(OltBaseTest):
    """Verify openflow access from OLT device"""

    def runTest(self):
        logging.info("Running ControllerAccess test")

        # implicitly testing access to the openflow device
        # and deleting all residual flows and groups
        delete_all_flows(self.controller)
        delete_all_groups(self.controller)


class TestScenario1SingleOnu(OltBaseTest):
    """
    Run a comprehensive test scenrario on the OLT, with one ONU.

    Plan:

    0.  Reset the OLT into a clean state
    1.  Setup the OLT to pass authentication (EAPOL) to controller
        from any port, and test it.
    2.  Setup the OLT to pass unicast traffic for the ONU
    3.  Verify that unicast traffic works in both directions (use a few hundred frames in both ways)
    4.  Setup IGMP forwarding toward the controller
    5.  Send periodic IGMP queries out toward the ONU and verify its arrival
    6.  Send in an IGMP join request for one channel (specific multicast address) and verify that
        the controller receives it.
    7.  Setup flows for forwarding multicast traffic from the OLT port toward the ONU(s)
    8.  Verify that multicast packets can reach the ONU
    9.  Verify that bidirectional unicast traffic still works across the PON
    10. Change channel to a new multicast group and verify both multicast receiption as well as
        unicast traffic works. This step involves:
        - sending a leave message by the ONU to the controller and verify its reception
        - sending a join message and verify its reception
        - removing the existing multicast flow
        - adding a new multicast flow
        - verify that original flow no longer flows
        - verify new flow
        - verify that unicast still works
    11. Add a second channel while keeping the existing one. Verify all what needs to be verified
        (similar as above)
    12. Add two more multicast channels, and verify everything
    13. Flip a channel for one of the multicast channels, and verify everything
    14. Tear down the test.
    """

    def runTest(self):
        logging.info("Running %s" % self.__class__.__name__)

        # Some constants
        s_vlan_id = 111
        mcast_vlan_id = 140
        mcast_groups = Thing(
            ch1="230.10.10.10",
            ch2="231.11.11.11",
            ch3="232.12.12.12",
            ch4="233.13.13.13",
            ch5="234.14.14.14"
        )
        onu1 = Thing(
            port=onu_port,
            ip="13.14.14.13",
            mac="b6:b8:3e:fb:1a:3f",
            c_vlan_id=13
        )

        # 0.  Reset the OLT into a clean state
        self.resetOlt()

        # 1.  Setup the OLT to pass authentication (EAPOL) to controller
        #     from any port, and test it.
        self.installEapolRule()
        self.sendEapolIn()

        # 2.  Setup the OLT to pass unicast traffic for the ONU1
        self.installDoubleTaggingRules(s_vlan_id, onu1.c_vlan_id, self.getCookieBlock())

        # 3.  Verify that unicast traffic works in both directions (use a few hundred frames in both ways)
        self.testPacketFlow(s_vlan_id, onu1.c_vlan_id)  # this tests just one packet in each way
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 100)

        # 4.  Setup IGMP forwarding toward the controller
        self.installIgmpRule(self.getCookieBlock())
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 5.  Send periodic IGMP queries out toward the ONU and verify its arrival
        self.testIgmpQueryOut()
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 6.  Send in an IGMP join request for one channel (specific multicast address) and verify that
        #     the controller receives it.
        self.sendIgmpReport(join=[mcast_groups.ch1])

        # 7.  Setup flows for forwarding multicast traffic from the OLT port toward the ONU(s)
        ch1_cookie = self.getCookieBlock()
        ch1_group_id = 1
        self.setupMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu1.port], ch1_group_id, ch1_cookie)

        # 8.  Verify that multicast packets can reach the ONU
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], 10)

        # 9.  Verify that bidirectional unicast traffic still works across the PON
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 10. Change channel to a new multicast group and verify both multicast receiption as well as
        #     unicast traffic works. This step involves:
        #     - sending a leave message by the ONU to the controller and verify its reception
        #     - sending a join message and verify its reception
        #     - removing the existing multicast flow
        #     - adding a new multicast flow
        #     - verify that original flow no longer flows
        #     - verify new flow
        #     - verify that unicast still works
        self.sendIgmpReport(leave=[mcast_groups.ch1], join=[mcast_groups.ch2])
        self.removeMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu1.port], ch1_group_id, ch1_cookie)
        ch2_cookie = self.getCookieBlock()
        ch2_group_id = 2
        self.setupMcastChannel(mcast_groups.ch2, mcast_vlan_id, [onu1.port], ch2_group_id, ch2_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 11. Add a second channel while keeping the existing one. Verify all what needs to be verified
        #     (similar as above)
        self.sendIgmpReport(join=[mcast_groups.ch2, mcast_groups.ch3])
        ch3_cookie = self.getCookieBlock()
        ch3_group_id = 3
        self.setupMcastChannel(mcast_groups.ch3, mcast_vlan_id, [onu1.port], ch3_group_id, ch3_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 12. Add two more multicast channels, and verify everything again
        self.sendIgmpReport(join=[mcast_groups.ch2, mcast_groups.ch3, mcast_groups.ch4, mcast_groups.ch5])
        ch4_cookie = self.getCookieBlock()
        ch4_group_id = 4
        self.setupMcastChannel(mcast_groups.ch4, mcast_vlan_id, [onu1.port], ch4_group_id, ch4_cookie)
        ch5_cookie = self.getCookieBlock()
        ch5_group_id = 5
        self.setupMcastChannel(mcast_groups.ch5, mcast_vlan_id, [onu1.port], ch5_group_id, ch5_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch4, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch5, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 13. Flip a channel for one of the multicast channels, and verify everything (ch3 -> ch1)
        self.sendIgmpReport(join=[mcast_groups.ch1, mcast_groups.ch2, mcast_groups.ch4, mcast_groups.ch5],
                            leave=[mcast_groups.ch3])
        self.removeMcastChannel(mcast_groups.ch3, mcast_vlan_id, [onu1.port], ch3_group_id, ch3_cookie)
        ## reusing the same group id and cookie
        self.setupMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu1.port], ch1_group_id, ch1_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch4, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch5, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 14. Tear down the test.
        self.resetOlt()


class TestScenario2TwoOnus(OltBaseTest):
    """
    Run a comprehensive test scenario involving the OLT and two ONUs.

    Plan:

    0.  Reset the OLT into a clean state

    1.  Setup the OLT to pass authentication (EAPOL) to controller from ONU1
        and test it.
    2.  Setup the OLT to pass unicast traffic for the ONU1
    3.  Verify that unicast traffic works in both directions (use a few hundred frames in both ways)
    4.  Setup IGMP forwarding toward the controller
    5.  Send periodic IGMP queries out toward the ONU1 and verify its arrival
    6.  Send in an IGMP join request for one channel (specific multicast address) and verify that
        the controller receives it.
    7.  Setup flows for forwarding multicast traffic from the OLT port toward ONU1
    8.  Verify that multicast packets can reach ONU1
    9.  Verify that bidirectional unicast traffic still works across the PON
    10. Change channel to a new multicast group and verify both multicast receiption as well as
        unicast traffic works. This step involves:
        - sending a leave message by the ONU to the controller and verify its reception
        - sending a join message and verify its reception
        - removing the existing multicast flow
        - adding a new multicast flow
        - verify that original flow no longer flows
        - verify new flow
        - verify that unicast still works
    11. Add a second channel while keeping the existing one. Verify all what needs to be verified
        (similar as above) - at this point ONU1 is tuned into ch2 and ch3

    12. Setup the OLT to pass authentication (EAPOL) to controller from ONU2
        and test it.
    13. Setup the OLT to pass unicast traffic for the ONU2
    14. Verify that unicast traffic works in both directions (use a few hundred frames in both ways)

    15. Verify that both ONUs can send/receive unicast and ONU1 can still see its 2 channels

    16. Setup IGMP forwarding toward the controller
    17. Send periodic IGMP queries out toward the ONU2 and verify its arrival
    18. Send in an IGMP join request for one channel (specific multicast address) and verify that
        the controller receives it.
    19. Setup flows for forwarding multicast traffic from the OLT port toward ONU2
    20. Verify that multicast packets can reach ONU2
    21. Verify that bidirectional unicast traffic still works across the PON for both ONUs
    22. Change channel to a new multicast group and verify both multicast receiption as well as
        unicast traffic works. This step involves:
        - sending a leave message by the ONU to the controller and verify its reception
        - sending a join message and verify its reception
        - removing the existing multicast flow
        - adding a new multicast flow
        - verify that original flow no longer flows
        - verify new flow
        - verify that unicast still works
        - verify everything for ONU1 too
    23. Add a second channel while keeping the existing one. Verify all what needs to be verified
        (similar as above) - at this point ONU1 is tuned into ch2 and ch3 and ONU2 is
        tuned to ch2 and ch5

    24. Flip a channel for ONU1 and verify everything
    25. Tear down the test.

    """

    def runTest(self):
        logging.info("Running %s" % self.__class__.__name__)

        # Some constants
        s_vlan_id = 111
        mcast_vlan_id = 140
        mcast_groups = Thing(
            ch1="230.10.10.10",
            ch2="231.11.11.11",
            ch3="232.12.12.12",
            ch4="233.13.13.13",
            ch5="234.14.14.14"
        )
        onu1 = Thing(
            port=onu_port,
            ip="13.14.14.13",
            mac="b6:b8:3e:fb:1a:3f",
            c_vlan_id=13
        )
        onu2 = Thing(
            port=onu_port2,
            ip="113.114.114.113",
            mac="b6:b8:3e:fb:aa:aa",
            c_vlan_id=913
        )

        # 0.  Reset the OLT into a clean state
        self.resetOlt()

        # 1.  Setup the OLT to pass authentication (EAPOL) to controller from ONU1
        #     and test it.
        self.installEapolRule()
        self.sendEapolIn()

        # 2.  Setup the OLT to pass unicast traffic for the ONU1
        self.installDoubleTaggingRules(s_vlan_id, onu1.c_vlan_id, self.getCookieBlock())

        # 3.  Verify that unicast traffic works in both directions (use a few hundred frames in both ways)
        self.testPacketFlow(s_vlan_id, onu1.c_vlan_id)  # this tests just one packet in each way
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 100)

        # 4.  Setup IGMP forwarding toward the controller
        self.installIgmpRule(self.getCookieBlock())
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 5.  Send periodic IGMP queries out toward the ONU1 and verify its arrival
        self.testIgmpQueryOut()
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 6.  Send in an IGMP join request for one channel (specific multicast address) and verify that
        #     the controller receives it.
        self.sendIgmpReport(join=[mcast_groups.ch1])

        # 7.  Setup flows for forwarding multicast traffic from the OLT port toward ONU1
        ch1_cookie = self.getCookieBlock()
        ch1_group_id = 1
        self.setupMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu1.port], ch1_group_id, ch1_cookie)

        # 8.  Verify that multicast packets can reach ONU1
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], 10)

        # 9.  Verify that bidirectional unicast traffic still works across the PON
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 10. Change channel to a new multicast group and verify both multicast receiption as well as
        #     unicast traffic works. This step involves:
        #     - sending a leave message by the ONU to the controller and verify its reception
        #     - sending a join message and verify its reception
        #     - removing the existing multicast flow
        #     - adding a new multicast flow
        #     - verify that original flow no longer flows
        #     - verify new flow
        #     - verify that unicast still works
        self.sendIgmpReport(leave=[mcast_groups.ch1], join=[mcast_groups.ch2])
        self.removeMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu1.port], ch1_group_id, ch1_cookie)
        ch2_cookie = self.getCookieBlock()
        ch2_group_id = 2
        self.setupMcastChannel(mcast_groups.ch2, mcast_vlan_id, [onu1.port], ch2_group_id, ch2_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 11. Add a second channel while keeping the existing one. Verify all what needs to be verified
        #     (similar as above) - at this point ONU1 is tuned into ch2 and ch3
        self.sendIgmpReport(join=[mcast_groups.ch2, mcast_groups.ch3])
        ch3_cookie = self.getCookieBlock()
        ch3_group_id = 3
        self.setupMcastChannel(mcast_groups.ch3, mcast_vlan_id, [onu1.port], ch3_group_id, ch3_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 12. Setup the OLT to pass authentication (EAPOL) to controller from ONU2
        #     and test it.
        self.installEapolRule(onu_port2)
        self.sendEapolIn(onu_port2)

        # 13. Setup the OLT to pass unicast traffic for the ONU2
        self.installDoubleTaggingRules(s_vlan_id, onu2.c_vlan_id, self.getCookieBlock(), onu_port2)

        # 14. Verify that unicast traffic works in both directions (use a few hundred frames in both ways)
        self.testPacketFlow(s_vlan_id, onu2.c_vlan_id, onu_port2)  # this tests just one packet in each way
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, 100, onu=onu_port2)

        # 15. Verify that both ONU1 can send/receive unicast and ONU1 can still see its 2 channels
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port], 10)
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port], 10)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 16. Setup IGMP forwarding toward the controller
        # Note: this is actually not needed since the rule is not port specific - maybe it should be?
        #self.installIgmpRule(self.getCookieBlock())
        #self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows

        # 17. Send periodic IGMP queries out toward the ONU2 and verify its arrival
        self.testIgmpQueryOut(onu_port2)
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10) # to check that unicast still flows
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, 10, onu=onu_port2) # to check that unicast still flows

        # 18. Send in an IGMP join request for one channel (specific multicast address) and verify that
        #     the controller receives it.
        self.sendIgmpReport(join=[mcast_groups.ch1], onu=onu_port2)

        # 19. Setup flows for forwarding multicast traffic from the OLT port toward ONU2: ch1
        self.setupMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu2.port], ch1_group_id, ch1_cookie)

        # 20. Verify that ch1 multicast packets can reach ONU2, but not ONU1
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu2.port], 10)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port], expect_to_be_blocked=True)

        # 21. Verify that bidirectional unicast traffic still works across the PON for both ONUs
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id, 10)
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, 10, onu=onu_port2)

        # 22. Change channel to a new multicast group and verify both multicast receiption as well as
        #     unicast traffic works. This step involves:
        #     - sending a leave message by the ONU to the controller and verify its reception
        #     - sending a join message and verify its reception
        #     - removing the existing multicast flow
        #     - adding a new multicast flow
        #     - verify that original flow no longer flows
        #     - verify new flow
        #     - verify that unicast still works
        #     - verify everything for ONU1 too
        self.sendIgmpReport(join=[mcast_groups.ch2], leave=[mcast_groups.ch1], onu=onu2.port)
        self.removeMcastChannel(mcast_groups.ch1, mcast_vlan_id, [onu2.port], ch1_group_id, ch1_cookie)
        self.updateMcastChannel(ch2_group_id, port_list=[onu1.port, onu2.port])
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port, onu2.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port, onu2.port])
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port])
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id)
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, onu=onu_port2)

        # 23. Add a second channel for ONU2 while keeping the existing one. Verify all what needs to be verified
        #     (similar as above) - at this point ONU1 is tuned into ch2 and ch3 and ONU2 is
        #     tuned to ch2 and ch5
        self.sendIgmpReport(join=[mcast_groups.ch2, mcast_groups.ch5], onu=onu2.port)
        ch5_cookie = self.getCookieBlock()
        ch5_group_id = 5
        self.setupMcastChannel(mcast_groups.ch5, mcast_vlan_id, [onu2.port], ch5_group_id, ch5_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port, onu2.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port, onu2.port])
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port])
        self.testMcastFlow(mcast_groups.ch5, mcast_vlan_id, [onu2.port])
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id)
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, onu=onu_port2)

        # 24. Flip a channel for ONU1 and verify everything (ch3 -> ch4)
        self.sendIgmpReport(leave=[mcast_groups.ch3], join=[mcast_groups.ch2, mcast_groups.ch4], onu=onu1.port)
        self.removeMcastChannel(mcast_groups.ch3, mcast_vlan_id, [onu1.port], ch3_group_id, ch3_cookie)
        ch4_cookie = self.getCookieBlock()
        ch4_group_id = 4
        self.setupMcastChannel(mcast_groups.ch4, mcast_vlan_id, [onu1.port], ch4_group_id, ch4_cookie)
        self.testMcastFlow(mcast_groups.ch1, mcast_vlan_id, [onu1.port, onu2.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch2, mcast_vlan_id, [onu1.port, onu2.port])
        self.testMcastFlow(mcast_groups.ch3, mcast_vlan_id, [onu1.port, onu2.port], expect_to_be_blocked=True)
        self.testMcastFlow(mcast_groups.ch4, mcast_vlan_id, [onu1.port])
        self.testMcastFlow(mcast_groups.ch5, mcast_vlan_id, [onu2.port])
        self.testSustainedPacketFlow(s_vlan_id, onu1.c_vlan_id)
        self.testSustainedPacketFlow(s_vlan_id, onu2.c_vlan_id, onu=onu_port2)

        # 25. Tear down the test.
        self.resetOlt()