
# 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
"""
import Queue

from oftest import config
import inspect
import logging
import oftest.base_tests as base_tests
import ofp
from oftest.testutils import *
from accton_util import *
from utils import *

MAX_INTERNAL_VLAN = 4094

class L2ForwardingStackedVLAN( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table
        and VLAN 1 table. This is necessary for classify packets in VPWS

        One rules is necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1ff2:0x1fff (VLAN 4082) |
            GoTo = 11 (VLAN 1) popVlanAction ovid = 8178 |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1

        One rules is necessary in VLAN 1 table (11):
        2)  inPort = 12 (Physical)  vlanId = 0x1f8e (VLAN 3982) ovid = 0x1ff2 (VLAN 4082) |
            GoTo = 20 (Termination MAC) newTpid2 = 0x8100 newVlanId2 = 0x1ff2 (VLAN 4082) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 2

        In this test case outer_vlan_id = (MAX_INTERNAL_VLAN - port_no) and
        inner_vlan_id = (MAX_INTERNAL_VLAN - 100 - port_no)
        The remaining part of the test is based on the use of the bridging table
    """

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                add_one_vlan_table_flow(
                    self.controller,
                    in_port,
                    vlan_id=outer_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_STACKED
                    )
                add_one_vlan_1_table_flow(
                    self.controller,
                    in_port,
                    new_outer_vlan_id=-1,
                    outer_vlan_id=outer_vlan_id,
                    inner_vlan_id=inner_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_TAG
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        outer_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        outer_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=108,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )

class L2ForwardingStackedVLAN2( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table
        and VLAN 1 table. This is necessary for classify packets in VPWS. In this test
        case we verify the change of outer vlan VLAN 1 table.

        One rules is necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1ff2:0x1fff (VLAN 4082) |
            GoTo = 11 (VLAN 1) popVlanAction ovid = 8178 |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1

        One rules is necessary in VLAN 1 table (11):
        2)  inPort = 12 (Physical)  vlanId = 0x1f8e (VLAN 3982) ovid = 0x1ff2 (VLAN 4082) |
            GoTo = 20 (Termination MAC) newTpid2 = 0x8100 newVlanId2 = 0x1f2a (VLAN 3882) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 2

        In this test case:
        1) outer_vlan_id = (MAX_INTERNAL_VLAN - port_no)
        2) inner_vlan_id = (MAX_INTERNAL_VLAN - 100 - port_no)
        3) new_outer_vlan_id = (MAX_INTERNAL_VLAN - 200 - port_no)

        The remaining part of the test is based on the use of the bridging table
    """

    MAX_INTERNAL_VLAN = 4094

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                new_outer_vlan_id = MAX_INTERNAL_VLAN  - 200 - in_port
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                add_one_vlan_table_flow(
                    self.controller,
                    in_port,
                    vlan_id=outer_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_STACKED
                    )
                add_one_vlan_1_table_flow(
                    self.controller,
                    in_port,
                    new_outer_vlan_id=new_outer_vlan_id,
                    outer_vlan_id=outer_vlan_id,
                    inner_vlan_id=inner_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_TAG
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        new_outer_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        new_outer_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                new_outer_vlan_id = MAX_INTERNAL_VLAN  - 200 - in_port
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=108,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=108,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=new_outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                    pkt = str( parsed_pkt )
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )

class L2ForwardingStackedVLAN3( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table.
        This is necessary for classify packets in VPWS. In this test
        case we verify the change of outer vlan pushing another vlan in VLAN table.

        One rules is necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1f8e:0x1fff (VLAN 3982) |
            GoTo = 20 (Termination MAC) newTpid2 = 0x8100 newVlanId2 = 0x1ff2 (VLAN 4082) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1

        In this test case:
        1) outer_vlan_id = (MAX_INTERNAL_VLAN - port_no)
        2) inner_vlan_id = (MAX_INTERNAL_VLAN - 100 - port_no)

        The remaining part of the test is based on the use of the bridging table
    """

    MAX_INTERNAL_VLAN = 4094

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                add_vlan_table_flow_pvid(
                    self.controller,
                    in_port,
                    match_vid=inner_vlan_id,
                    pvid=outer_vlan_id,
                    send_barrier=True
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        outer_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        outer_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet(
                        pktlen=108,
                        dl_vlan_enable=True,
                        vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=112,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                    pkt = str( parsed_pkt )
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )

class L2ForwardingStackedVLAN4( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table
        and VLAN 1 table. This is necessary for classify packets in VPWS. In this test
        case we verify the change of outer vlan popping the tag in VLAN 1 table.

        One rules is necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1ff2:0x1fff (VLAN 4082) |
            GoTo = 11 (VLAN 1) popVlanAction ovid = 8178 |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1

        One rules is necessary in VLAN table (11):
        1)  inPort = 12 (Physical)  vlanId = 0x1f8e (VLAN 3982) ovid = 0x1ff2 (VLAN 4082) |
            GoTo = 20 (Termination MAC) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 2

        In this test case:
        1) outer_vlan_id = (MAX_INTERNAL_VLAN - port_no)
        2) inner_vlan_id = (MAX_INTERNAL_VLAN - 100 - port_no)

        The remaining part of the test is based on the use of the bridging table
    """

    MAX_INTERNAL_VLAN = 4094

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                add_one_vlan_table_flow(
                    self.controller,
                    in_port,
                    vlan_id=outer_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_STACKED
                    )
                add_one_vlan_1_table_flow(
                    self.controller,
                    in_port,
                    new_outer_vlan_id=-1,
                    outer_vlan_id=outer_vlan_id,
                    inner_vlan_id=inner_vlan_id,
                    flag=VLAN_TABLE_FLAG_ONLY_UNTAG
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        inner_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        inner_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=112,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    parsed_pkt = simple_tcp_packet(
                        pktlen=108,
                        dl_vlan_enable=True,
                        vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                    pkt = str( parsed_pkt )
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )

class L2ForwardingStackedVLAN5( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table
        and VLAN 1 table. This is necessary for classify packets in VPWS. In this test
        case we verify the change of outer vlan in VLAN table.

        One rules is necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1ff2:0x1fff (VLAN 4082) |
            GoTo = 20 (VLAN 1) newVlanId = 0x1f2a (VLAN 3882) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1

        In this test case:
        1) outer_vlan_id = (MAX_INTERNAL_VLAN - port_no)
        3) new_outer_vlan_id = (MAX_INTERNAL_VLAN - 200 - port_no)

        The remaining part of the test is based on the use of the bridging table
    """

    MAX_INTERNAL_VLAN = 4094

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                new_outer_vlan_id = MAX_INTERNAL_VLAN  - 200 - in_port
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                add_one_vlan_table_flow_translation(
                    self.controller,
                    in_port,
                    vlan_id=outer_vlan_id,
                    new_vlan_id=new_outer_vlan_id,
                    vrf=0,
                    flag=VLAN_TABLE_FLAG_ONLY_TAG,
                    send_barrier=False
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        new_outer_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        new_outer_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                new_outer_vlan_id = MAX_INTERNAL_VLAN  - 200 - in_port
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id =MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=112,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=112,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=new_outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                    pkt = str( parsed_pkt )
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )

class L2ForwardingStackedVLAN6( base_tests.SimpleDataPlane ):
    """
        Verify the proper operation of the pipeline part which includes VLAN table.
        This is necessary for classify packets priority tagged. In this test
        case we verify the change of outer vlan in VLAN table.

        Two rules are necessary in VLAN table (10):
        1)  inPort = 12 (Physical)  vlanId:mask = 0x1000:0x1fff (VLAN 0) |
            GoTo = 20 (Termination MAC) newVlanId = 0x1f8e (VLAN 3982) newTpid2 = 0x8100 newVlanId2 = 0x1ff2 (VLAN 4082) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 3
        2)  inPort = 12 (Physical)  vlanId:mask = 0x1ff2:0x1fff (VLAN 4082) |
            GoTo = 20 (Termination MAC) |
            priority = 0 hard_time = 0 idle_time = 0 cookie = 1


        In this test case:
        1) outer_vlan_id = (MAX_INTERNAL_VLAN - port_no)
        3) inner_vlan_id = (MAX_INTERNAL_VLAN - 100 - port_no)

        The remaining part of the test is based on the use of the bridging table
    """

    MAX_INTERNAL_VLAN = 4094

    def runTest( self ):
        groups = Queue.LifoQueue( )
        try:
            if len( config[ "port_map" ] ) < 2:
                logging.info( "Port count less than 2, can't run this case" )
                return

            ports = sorted( config[ "port_map" ].keys( ) )
            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                add_one_vlan_table_flow(
                    ctrl=self.controller,
                    of_port=in_port,
                    vlan_id=outer_vlan_id,
                    vrf=0,
                    flag=VLAN_TABLE_FLAG_ONLY_BOTH,
                    send_barrier=False
                    )
                add_one_vlan_table_flow(
                    ctrl=self.controller,
                    of_port=in_port,
                    out_vlan_id=outer_vlan_id,
                    vlan_id=inner_vlan_id,
                    vrf=0,
                    flag=VLAN_TABLE_FLAG_PRIORITY,
                    send_barrier=False
                    )
                for out_port in ports:
                    if out_port == in_port:
                        continue
                    L2gid, l2msg = add_one_l2_interface_group(
                        self.controller,
                        out_port,
                        outer_vlan_id,
                        True,
                        False
                        )
                    groups.put( L2gid )
                    add_bridge_flow(
                        self.controller,
                        [ 0x00, 0x12, 0x34, 0x56, 0x78, in_port ],
                        outer_vlan_id,
                        L2gid,
                        True
                        )

            do_barrier( self.controller )

            for in_port in ports:
                outer_vlan_id = MAX_INTERNAL_VLAN - in_port
                inner_vlan_id = MAX_INTERNAL_VLAN - 100 - in_port
                mac_dst = '00:12:34:56:78:%02X' % in_port

                parsed_pkt = simple_tcp_packet(
                        pktlen=112,
                        dl_vlan_enable=True,
                        vlan_vid=0,
                        eth_dst=mac_dst,
                        )
                pkt = str( parsed_pkt )
                self.dataplane.send( in_port, pkt )

                # change dest based on port number
                for out_port in ports:
                    parsed_pkt = simple_tcp_packet_two_vlan(
                        pktlen=116,
                        out_dl_vlan_enable=True,
                        out_vlan_vid=outer_vlan_id,
                        in_dl_vlan_enable=True,
                        in_vlan_vid=inner_vlan_id,
                        eth_dst=mac_dst,
                        )
                    pkt = str( parsed_pkt )
                    if out_port == in_port:
                        verify_no_packet( self, pkt, in_port )
                        continue
                    verify_packet( self, pkt, out_port )
                    verify_no_other_packets( self )

        finally:
            delete_all_flows( self.controller )
            delete_groups( self.controller, groups )
            delete_all_groups( self.controller )