| |
| # 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 |
| |
| import os |
| from oftest import config |
| import inspect |
| import logging |
| import oftest.base_tests as base_tests |
| import ofp |
| import time |
| from oftest.oft12.testutils import delete_all_flows_one_table |
| from oftest.testutils import * |
| from accton_util import * |
| from oftest.utils import * |
| import pexpect |
| import json |
| |
| |
| class FabricSW_OF_PacketInUDP_TC_0010( base_tests.SimpleDataPlane ): |
| """ |
| Verify ACL rule for IP_PROTO=2 wont match a UDP packet and a rule for IP_PROTO=17 WILL match a UDP packet. |
| """ |
| |
| def runTest( self ): |
| try: |
| parsed_vlan_pkt = simple_udp_packet( pktlen=104, vlan_vid=0x1001, dl_vlan_enable=True ) |
| vlan_pkt = str( parsed_vlan_pkt ) |
| # create match |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0800 ) ) |
| match.oxm_list.append( ofp.oxm.ip_proto( 2 ) ) |
| 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( "Inserting packet in flow to controller" ) |
| self.controller.message_send( request ) |
| |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for of_port in pair: |
| logging.info( "PacketInMiss test, port %d", of_port ) |
| self.dataplane.send( of_port, vlan_pkt ) |
| |
| verify_no_packet_in( self, vlan_pkt, of_port ) |
| delete_all_flows( self.controller ) |
| do_barrier( self.controller ) |
| |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0800 ) ) |
| match.oxm_list.append( ofp.oxm.ip_proto( 17 ) ) |
| 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( "Inserting packet in flow to controller" ) |
| self.controller.message_send( request ) |
| do_barrier( self.controller ) |
| |
| for of_port in config[ "port_map" ].keys( ): |
| logging.info( "PacketInMiss test, port %d", of_port ) |
| self.dataplane.send( of_port, vlan_pkt ) |
| |
| verify_packet_in( self, vlan_pkt, of_port, ofp.OFPR_ACTION ) |
| |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class ArpNL2( base_tests.SimpleDataPlane ): |
| """ |
| Needs a description, disabled for now. Also needs try/finally |
| """ |
| def runTest( self ): |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0806 ) ) |
| 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=40000 ) |
| self.controller.message_send( request ) |
| for port in ports: |
| add_one_l2_interface_group( self.controller, port, 1, False, False ) |
| add_one_vlan_table_flow( self.controller, port, 1, flag=VLAN_TABLE_FLAG_ONLY_BOTH ) |
| group_id = encode_l2_interface_group_id( 1, port ) |
| add_bridge_flow( self.controller, [ 0x00, 0x12, 0x34, 0x56, 0x78, port ], 1, group_id, True ) |
| do_barrier( self.controller ) |
| parsed_arp_pkt = simple_arp_packet( ) |
| arp_pkt = str( parsed_arp_pkt ) |
| |
| for out_port in ports: |
| self.dataplane.send( out_port, arp_pkt ) |
| verify_packet_in( self, arp_pkt, out_port, ofp.OFPR_ACTION ) |
| # change dest based on port number |
| mac_dst = '00:12:34:56:78:%02X' % out_port |
| for in_port in ports: |
| if in_port == out_port: |
| continue |
| # change source based on port number to avoid packet-ins from learning |
| mac_src = '00:12:34:56:78:%02X' % in_port |
| parsed_pkt = simple_tcp_packet( eth_dst=mac_dst, eth_src=mac_src ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for ofport in ports: |
| if ofport in [ out_port ]: |
| verify_packet( self, pkt, ofport ) |
| else: |
| verify_no_packet( self, pkt, ofport ) |
| |
| verify_no_other_packets( self ) |
| |
| class FabricSW_OF_PacketInArp_TC_0005( base_tests.SimpleDataPlane ): |
| """ |
| Verify Packet-in message from eth_type 0x806 on ACL table |
| """ |
| |
| def runTest( self ): |
| try: |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| parsed_arp_pkt = simple_arp_packet( ) |
| arp_pkt = str( parsed_arp_pkt ) |
| # create match |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0806 ) ) |
| 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( "Inserting arp flow " ) |
| self.controller.message_send( request ) |
| do_barrier( self.controller ) |
| |
| for of_port in pair: |
| logging.info( "PacketInArp test, sending arp packet to port %d", of_port ) |
| self.dataplane.send( of_port, arp_pkt ) |
| |
| verify_packet_in( self, arp_pkt, of_port, ofp.OFPR_ACTION ) |
| |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class PacketInIPTable( base_tests.SimpleDataPlane ): |
| """ |
| Verify Packet-in message from IP table when controller action is used |
| Send a packet to each dataplane port and verify that a packet |
| in message is received from the controller for each |
| #todo verify you stop receiving after adding rule |
| """ |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| |
| for port in ports: |
| # add l2 interface group |
| vlan_id = port |
| add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, is_tagged=True, |
| send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, vlan_id=vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, l3_msg.group_id, |
| send_ctrl=True ) |
| Groups.put( l3_msg.group_id ) |
| |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| mac_src = '00:00:00:22:22:%02X' % in_port |
| ip_src = '192.168.%02d.1' % in_port |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % out_port |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=in_port, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet_in( self, pkt, in_port, ofp.OFPR_ACTION ) |
| # verify_no_other_packets(self) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF_L2FloodQinQ_TC_0015( base_tests.SimpleDataPlane ): |
| """ |
| Verify Vlan based flooding of QinQ based on its outer vlan |
| """ |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 100 |
| |
| for port in pair: |
| L2gid, l2msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| add_one_vlan_table_flow( self.controller, port, vlan_id=vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| Groups.put( L2gid ) |
| |
| msg = add_l2_flood_group( self.controller, pair, vlan_id, vlan_id ) |
| Groups.put( msg.group_id ) |
| add_bridge_flow( self.controller, None, vlan_id, msg.group_id, True ) |
| do_barrier( self.controller ) |
| |
| # verify flood |
| for ofport in pair: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan( pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id, 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 ) |
| self.dataplane.send( ofport, pkt ) |
| # self won't rx packet |
| verify_no_packet( self, pkt, ofport ) |
| # others will rx packet |
| tmp_ports = list( pair ) |
| tmp_ports.remove( ofport ) |
| verify_packets( self, pkt, tmp_ports ) |
| |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| |
| @disabled |
| class L2FloodTagged( base_tests.SimpleDataPlane ): |
| """ |
| currently disabled; fix with try/finally |
| Test L2 flood to a vlan |
| Send a packet with unknown dst_mac and check if the packet is flooded to all ports except inport |
| """ |
| |
| def runTest( self ): |
| # Hashes Test Name and uses it as id for installing unique groups |
| vlan_id = abs( hash( inspect.stack( )[ 0 ][ 3 ] ) ) % (256) |
| print vlan_id |
| |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| # Installing flows to avoid packet-in |
| for port in ports: |
| add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| add_one_vlan_table_flow( self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| msg = add_l2_flood_group( self.controller, ports, vlan_id, vlan_id ) |
| add_bridge_flow( self.controller, None, vlan_id, msg.group_id, True ) |
| do_barrier( self.controller ) |
| |
| # verify flood |
| for ofport in ports: |
| # change dest based on port number |
| pkt = str( |
| simple_tcp_packet( dl_vlan_enable=True, vlan_vid=vlan_id, eth_dst='00:12:34:56:78:9a' ) ) |
| self.dataplane.send( ofport, pkt ) |
| # self won't rx packet |
| verify_no_packet( self, pkt, ofport ) |
| # others will rx packet |
| tmp_ports = list( ports ) |
| tmp_ports.remove( ofport ) |
| verify_packets( self, pkt, tmp_ports ) |
| verify_no_other_packets( self ) |
| |
| |
| class FabricSW_OF_L2UnicastTagged_TC_0020( base_tests.SimpleDataPlane ): |
| """ Verify Bridging works: match(VID, DST_MAC)> fwd(port) """ |
| |
| def runTest( self ): |
| |
| Groups = Queue.LifoQueue( ) |
| try: |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 1; |
| for port in pair: |
| L2gid, l2msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| add_one_vlan_table_flow( self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| Groups.put( L2gid ) |
| add_bridge_flow( self.controller, [ 0x00, 0x12, 0x34, 0x56, 0x78, port ], vlan_id, L2gid, |
| True ) |
| do_barrier( self.controller ) |
| |
| for out_port in pair: |
| # change dest based on port number |
| mac_dst = '00:12:34:56:78:%02X' % out_port |
| for in_port in pair: |
| if in_port == out_port: |
| continue |
| pkt = str( simple_tcp_packet( dl_vlan_enable=True, vlan_vid=vlan_id, eth_dst=mac_dst ) ) |
| self.dataplane.send( in_port, pkt ) |
| for ofport in pair: |
| if ofport in [ out_port ]: |
| verify_packet( self, pkt, ofport ) |
| else: |
| verify_no_packet( self, pkt, ofport ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF_Bridging_TC_0001( base_tests.SimpleDataPlane ): |
| """ |
| Verify bridging works including flooding with different vlans |
| ports[0] has vlan 31 untagged |
| ports[1] has vlan 31 untagged (native) and vlan 41 tagged |
| ARP request should be flooded |
| ARP reply should be forwarded by bridging rule |
| Both arp messages should also be copied to controller |
| """ |
| |
| def runTest( self ): |
| Groupd = 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() ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_p0_untagged = 31 |
| vlan_p1_tagged = 31 |
| vlan_p1_native = 41 |
| |
| #l2 interface groups and table 10 flows |
| L2p0gid, l2msg0 = add_one_l2_interface_group( self.controller, ports[0], vlan_p0_untagged, |
| is_tagged=False, send_barrier=False ) |
| add_one_vlan_table_flow( self.controller, ports[0], vlan_id=vlan_p0_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| L2p1gid, l2msg1 = add_one_l2_interface_group( self.controller, ports[1], vlan_p1_tagged, |
| is_tagged=True, send_barrier=False ) |
| add_one_vlan_table_flow( self.controller, ports[1], vlan_id=vlan_p1_tagged, flag=VLAN_TABLE_FLAG_ONLY_TAG, |
| send_barrier=True) |
| L2p1gid2, l2msg3 = add_one_l2_interface_group( self.controller, ports[1], vlan_p1_native, |
| is_tagged=False, send_barrier=False ) |
| add_one_vlan_table_flow( self.controller, ports[1], vlan_id=vlan_p1_native, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| #flooding groups |
| Floodmsg31 = add_l2_flood_group( self.controller, pair, vlan_p0_untagged, id=0 ) |
| Floodmsg41 = add_l2_flood_group( self.controller, [ ports[1] ], vlan_p1_native, id=0 ) |
| |
| #add bridging flows for flooding groups |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_p0_untagged, group_id=Floodmsg31.group_id ) |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_p1_native, group_id=Floodmsg41.group_id ) |
| do_barrier( self.controller ) |
| |
| # add bridging flows for dstMac+vlan |
| add_bridge_flow( self.controller, [ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 ], vlan_p0_untagged, L2p0gid, True ) |
| add_bridge_flow( self.controller, [ 0x00, 0x66, 0x77, 0x88, 0x99, 0xaa ], vlan_p1_tagged, L2p1gid, True ) |
| add_bridge_flow( self.controller, [ 0x00, 0x66, 0x77, 0x88, 0x99, 0xaa ], vlan_p1_native, L2p1gid2, True ) |
| |
| # add terminationMac flow |
| router_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, router_mac, vlan_p0_untagged ) |
| add_termination_flow( self.controller, 0, 0x0800, router_mac, vlan_p1_native ) |
| else: |
| add_termination_flow( self.controller, ports[0], 0x0800, router_mac, vlan_p0_untagged ) |
| add_termination_flow( self.controller, ports[1], 0x0800, router_mac, vlan_p1_tagged ) |
| add_termination_flow( self.controller, ports[1], 0x0800, router_mac, vlan_p1_native ) |
| |
| # add acl rule for arp |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0806 ) ) |
| 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 ) |
| self.controller.message_send( request ) |
| do_barrier( self.controller ) |
| |
| #acl rule for gateway ip |
| match = ofp.match( ) |
| match.oxm_list.append( ofp.oxm.eth_type( 0x0800 ) ) |
| match.oxm_list.append( ofp.oxm.ipv4_dst( 0xc0a80003 ) ) |
| 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 ) ] ), |
| ofp.instruction.clear_actions() ], |
| buffer_id=ofp.OFP_NO_BUFFER, priority=1 ) |
| self.controller.message_send( request ) |
| do_barrier( self.controller ) |
| |
| # send ARP request |
| parsed_arp_pkt = simple_arp_packet(pktlen=80, |
| eth_dst='ff:ff:ff:ff:ff:ff', |
| eth_src='00:66:77:88:99:aa', |
| vlan_vid=vlan_p1_tagged, |
| vlan_pcp=0, |
| arp_op=1, |
| ip_snd='192.168.0.2', |
| ip_tgt='192.168.0.1', |
| hw_snd='00:66:77:88:99:aa', |
| hw_tgt='00:00:00:00:00:00') |
| arp_pkt_to_send = str( parsed_arp_pkt ) |
| logging.info( "sending arp request to port %d", ports[1] ) |
| self.dataplane.send( ports[1], arp_pkt_to_send ) |
| verify_packet_in( self, arp_pkt_to_send, ports[1], ofp.OFPR_ACTION ) |
| parsed_arp_pkt_untagged = simple_arp_packet(pktlen=76, |
| eth_dst='ff:ff:ff:ff:ff:ff', |
| eth_src='00:66:77:88:99:aa', |
| vlan_vid=0, |
| vlan_pcp=0, |
| arp_op=1, |
| ip_snd='192.168.0.2', |
| ip_tgt='192.168.0.1', |
| hw_snd='00:66:77:88:99:aa', |
| hw_tgt='00:00:00:00:00:00') |
| arp_pkt_dest = str( parsed_arp_pkt_untagged ) |
| verify_packet( self, arp_pkt_dest, ports[0] ) |
| #verify_no_other_packets( self ) |
| |
| # send ARP reply |
| parsed_arp_pkt = simple_arp_packet(pktlen=76, |
| eth_dst='00:66:77:88:99:aa', |
| eth_src='00:11:22:33:44:55', |
| vlan_vid=0, |
| vlan_pcp=0, |
| arp_op=2, |
| ip_snd='192.168.0.1', |
| ip_tgt='192.168.0.2', |
| hw_snd='00:11:22:33:44:55', |
| hw_tgt='00:66:77:88:99:aa') |
| arp_pkt_to_send = str( parsed_arp_pkt ) |
| logging.info( "sending arp reply to port %d", ports[0] ) |
| self.dataplane.send( ports[0], arp_pkt_to_send ) |
| verify_packet_in( self, arp_pkt_to_send, ports[0], ofp.OFPR_ACTION ) |
| parsed_arp_pkt_tagged = simple_arp_packet(pktlen=80, |
| eth_dst='00:66:77:88:99:aa', |
| eth_src='00:11:22:33:44:55', |
| vlan_vid=vlan_p1_tagged, |
| vlan_pcp=0, |
| arp_op=2, |
| ip_snd='192.168.0.1', |
| ip_tgt='192.168.0.2', |
| hw_snd='00:11:22:33:44:55', |
| hw_tgt='00:66:77:88:99:aa') |
| arp_pkt_dest = str( parsed_arp_pkt_tagged ) |
| verify_packet( self, arp_pkt_dest, ports[1] ) |
| |
| # Send and verify VLAN 31 tagged unicast packets |
| mac_src = '00:12:34:56:78:%02X' % pair[1] |
| unicast_to_send = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_p1_tagged, in_dl_vlan_enable=False, |
| eth_dst='00:12:34:56:78:9a', eth_src=mac_src) |
| |
| unicast_to_expect = simple_tcp_packet_two_vlan(pktlen=104, out_dl_vlan_enable=False, |
| in_dl_vlan_enable=False, |
| eth_dst='00:12:34:56:78:9a', eth_src=mac_src) |
| |
| |
| tmp_ports = list(pair) |
| tmp_ports.remove(pair[1]) |
| pkt_s = str(unicast_to_send) |
| pkt_e = str(unicast_to_expect) |
| self.dataplane.send(pair[1], pkt_s) |
| verify_no_packet(self, pkt_s, pair[1]) |
| verify_packets(self, pkt_e, tmp_ports) |
| |
| # Send and verify untagged unicast packets |
| mac_src = '00:12:34:56:78:%02X' % pair[0] |
| unicast_to_expect = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_p1_tagged, out_vlan_pcp=0, in_dl_vlan_enable=False, |
| eth_dst='00:12:34:56:78:9a', eth_src=mac_src) |
| |
| unicast_to_send = simple_tcp_packet_two_vlan(pktlen=104, out_dl_vlan_enable=False, |
| in_dl_vlan_enable=False, |
| eth_dst='00:12:34:56:78:9a', eth_src=mac_src) |
| |
| tmp_ports = list(pair) |
| tmp_ports.remove(pair[0]) |
| pkt_s = str(unicast_to_send) |
| pkt_e = str(unicast_to_expect) |
| self.dataplane.send(pair[0], pkt_s) |
| verify_no_packet(self, pkt_s, pair[0]) |
| verify_packets(self, pkt_e, tmp_ports) |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| #print("done") |
| |
| |
| class FabricSW_OF_Mtu1500_TC_0035( base_tests.SimpleDataPlane ): |
| """ |
| Verifies basic mtu limits |
| """ |
| # Read config parameters from JSON file |
| 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_port = data['onos_port'] |
| onos_user = data['onos_user'] |
| onos_passwd = data['onos_passwd'] |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 18 |
| for port in pair: |
| L2gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| Groups.put( L2gid ) |
| add_bridge_flow( self.controller, [ 0x00, 0x12, 0x34, 0x56, 0x78, port ], vlan_id, L2gid, |
| True ) |
| do_barrier( self.controller ) |
| |
| # Send 1500 packet length, default MTU |
| for out_port in pair: |
| # change dest based on port number |
| mac_dst = '00:12:34:56:78:%02X' % out_port |
| for in_port in pair: |
| if in_port == out_port: |
| continue |
| pkt = str( simple_tcp_packet( pktlen=1500, dl_vlan_enable=True, vlan_vid=vlan_id, |
| eth_dst=mac_dst ) ) |
| self.dataplane.send( in_port, pkt ) |
| for ofport in pair: |
| if ofport in [ out_port ]: |
| verify_packet( self, pkt, ofport ) |
| else: |
| verify_no_packet( self, pkt, ofport ) |
| verify_no_other_packets( self ) |
| |
| # Change MTU of server's data ports to 2000 bytes |
| self.dataplane.port_mtu(pair[0], 2000) |
| self.dataplane.port_mtu(pair[1], 2000) |
| time.sleep(1) |
| |
| # Change MTU of switch's data ports to 1500 bytes |
| switch_port_set_mtu(self, pair[0], 1500) |
| switch_port_set_mtu(self, pair[1], 1500) |
| |
| time.sleep(1) |
| |
| # Send 2000 packet length |
| # change dest based on port number |
| mac_dst = '00:12:34:56:78:%02X' % pair[1] |
| pkt = str( simple_tcp_packet( pktlen=2000, dl_vlan_enable=True, vlan_vid=vlan_id, eth_dst=mac_dst ) ) |
| self.dataplane.send( pair[0], pkt ) |
| tmp_ports = list(pair) |
| tmp_ports.remove(pair[0]) |
| verify_no_packet(self, pkt, pair[0]) |
| verify_no_packet(self, pkt, pair[1]) |
| |
| finally: |
| self.dataplane.port_mtu(pair[0], 1500) |
| self.dataplane.port_mtu(pair[1], 1500) |
| time.sleep(1) |
| switch_port_set_mtu(self, pair[0], 9412) |
| switch_port_set_mtu(self, pair[1], 9412) |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF__32UcastTagged_TC_0055( base_tests.SimpleDataPlane ): |
| """ Verify /32 IP forwarding to L3 Unicast-> L2Interface""" |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| test_id = 26 |
| if len( config[ "port_map" ] ) < 2: |
| logging.info( "Port count less than 2, can't run this case" ) |
| return |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| vlan_id = port + test_id |
| # add l2 interface group and l3 unicast group |
| l2gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, l3_msg.group_id ) |
| Groups.put( l2gid ) |
| Groups.put( l3_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:32:%02X' % (test_id + in_port) |
| ip_src = '192.168.%02d.1' % (test_id + in_port) |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (test_id + out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + in_port), eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % (test_id + out_port) |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + out_port), eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class _32VPN( base_tests.SimpleDataPlane ): |
| """ |
| Verify /32 routing rule -> MPLS_VPN_Label -> MPLSInterface -> L2Interface |
| No ECMP group used |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # add l2 interface group |
| id = port |
| vlan_id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, True ) |
| dst_mac[ 5 ] = vlan_id |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=port, set_bos=1, set_ttl=32 ) |
| do_barrier( self.controller ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, vrf=2, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, mpls_label_gid, vrf=2 ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port), |
| eth_dst=switch_mac, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| label = (out_port, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_port), ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class _32EcmpVpn( base_tests.SimpleDataPlane ): |
| """ |
| Verify /32 routing rule -> L3 ECMP -> MPLS_VPN_Label -> MPLSInterface -> L2Interface |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # add l2 interface group |
| id = port |
| vlan_id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, True ) |
| dst_mac[ 5 ] = vlan_id |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=port, set_bos=1, set_ttl=32 ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, vlan_id, [ mpls_label_gid ] ) |
| do_barrier( self.controller ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, ecmp_msg.group_id ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| Groups._put( ecmp_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port), |
| eth_dst=switch_mac, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| label = (out_port, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_port), ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| |
| @disabled |
| class One_32EcmpVpn( base_tests.SimpleDataPlane ): |
| """ |
| Verify /32 routing rule -> L3 ECMP -> MPLS_VPN_Label -> MPLSInterface -> L2Interface |
| in only one direction |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| # add l2 interface group |
| id = ports[1] |
| in_offset = 19 |
| out_offset = 20 |
| vlan_id = ports[1] + out_offset |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, ports[1], vlan_id, True, True ) |
| dst_mac[ 5 ] = ports[1] |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=ports[1] + out_offset, set_bos=1, set_ttl=32 ) |
| # add ECMP group |
| ecmp_msg = add_l3_ecmp_group( self.controller, vlan_id, [ mpls_label_gid ] ) |
| do_barrier( self.controller ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, ports[0], 1, vlan_id=ports[0] + in_offset, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlanid=ports[0] + in_offset ) |
| else: |
| add_termination_flow( self.controller, ports[0], 0x0800, intf_src_mac, vlanid=ports[0] + in_offset ) |
| # add routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, ecmp_msg.group_id, send_barrier=True ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| in_port = ports[0] |
| out_port = ports[1] |
| ip_src = '192.168.%02d.1' % (in_port) |
| ip_dst = '192.168.%02d.1' % (out_port+out_offset) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port + in_offset), |
| eth_dst=switch_mac, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| label = (out_port+out_offset, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_port + out_offset), ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| #verify_no_other_packets( self ) |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_group(self.controller, ecmp_msg.group_id) |
| delete_group(self.controller, mpls_label_gid) |
| delete_group(self.controller, mpls_gid) |
| delete_group(self.controller, l2_gid) |
| |
| |
| class FabricSW_OF__32ECMPL3_TC_0050( base_tests.SimpleDataPlane ): |
| """ |
| Verifies /32 IP routing and ECMP with no label push |
| IP -> L3ECMP -> L3Unicast -> L2Interface |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| # Hashes Test Name and uses it as id for installing unique groups |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| vlan_id = port |
| id = port |
| # add l2 interface group |
| l2_gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, ecmp_msg.group_id ) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| Groups._put( ecmp_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:22:%02X' % in_port |
| ip_src = '192.168.%02d.1' % in_port |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % out_port |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=in_port, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class One_32ECMPL3( base_tests.SimpleDataPlane ): |
| """ |
| Verifies /32 IP routing and ECMP with no label push |
| IP -> L3ECMP -> L3Unicast -> L2Interface |
| in only one direction |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| # Hashes Test Name and uses it as id for installing unique groups |
| ports = config[ "port_map" ].keys( ) |
| inport = ports[0] |
| outport = ports[1] |
| in_offset = 19 |
| out_offset = 20 |
| vlan_id = outport + out_offset |
| id = outport |
| # add l2 interface group, l3 unicast and ecmp group for outport |
| l2_gid, msg = add_one_l2_interface_group( self.controller, outport, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = outport |
| l3_msg = add_l3_unicast_group( self.controller, outport, vlanid=vlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, of_port=inport, vlan_id=inport+in_offset, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlanid=inport+in_offset ) |
| else: |
| add_termination_flow( self.controller, in_port=inport, eth_type=0x0800, dst_mac=intf_src_mac, vlanid=inport+in_offset ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, ecmp_msg.group_id, send_barrier=True ) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| mac_src = '00:00:00:22:22:%02X' % inport |
| ip_src = '192.168.%02d.1' % inport |
| ip_dst = '192.168.%02d.1' % (outport+out_offset) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=inport+in_offset, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( inport, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % outport |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=outport+out_offset, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, outport ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| |
| |
| @disabled |
| class _24VPN( base_tests.SimpleDataPlane ): |
| """ Verify MPLS IP VPN Initiation from /32 rule without using ECMP """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # add l2 interface group |
| id = port |
| vlan_id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, True ) |
| dst_mac[ 5 ] = vlan_id |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=port, set_bos=1, set_ttl=32 ) |
| # ecmp_msg=add_l3_ecmp_group(self.controller, vlan_id, [mpls_label_gid]) |
| do_barrier( self.controller ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, mpls_label_gid ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port), |
| eth_dst=switch_mac, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| label = (out_port, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_port), ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class _24EcmpVpn( base_tests.SimpleDataPlane ): |
| """ Verify MPLS IP VPN Initiation from /24 rule using ECMP """ |
| |
| 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 |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # add l2 interface group |
| id = port |
| vlan_id = id |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, True ) |
| dst_mac[ 5 ] = vlan_id |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=port, set_bos=1, set_ttl=32 ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ mpls_label_gid ] ) |
| do_barrier( self.controller ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add routing flow |
| dst_ip = dip + (vlan_id << 8) |
| # add_unicast_routing_flow(self.controller, 0x0800, dst_ip, 0, mpls_label_gid, vrf=2) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, ecmp_msg.group_id, |
| vrf=0 ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| mac_src = '00:00:00:22:22:%02X' % (in_port) |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port), |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| label = (out_port, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_port), ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 FabricSW_OF_FloodGroupMod_TC_0030( base_tests.SimpleDataPlane ): |
| """ Modify a referenced flood group """ |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 1 |
| |
| for port in pair: |
| L2gid, l2msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| add_one_vlan_table_flow( self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| Groups.put( L2gid ) |
| |
| msg = add_l2_flood_group( self.controller, pair, vlan_id, vlan_id ) |
| Groups.put( msg.group_id ) |
| add_bridge_flow( self.controller, None, vlan_id, msg.group_id, True ) |
| do_barrier( self.controller ) |
| # verify flood |
| for ofport in pair: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan( pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id, 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 ) |
| self.dataplane.send( ofport, pkt ) |
| # self won't rx packet |
| verify_no_packet( self, pkt, ofport ) |
| # others will rx packet |
| tmp_ports = list( pair ) |
| tmp_ports.remove( ofport ) |
| verify_packets( self, pkt, tmp_ports ) |
| verify_no_other_packets( self ) |
| msg = mod_l2_flood_group( self.controller, [ pair[ 0 ] ], vlan_id, vlan_id ) |
| mac_src = '00:12:34:56:78:%02X' % pair[ 1 ] |
| parsed_pkt = simple_tcp_packet_two_vlan( pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id, 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 ) |
| self.dataplane.send( pair[ 1 ], pkt ) |
| verify_packets( self, pkt, [ pair[ 0 ] ] ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF__24ECMPL3_TC_0040( base_tests.SimpleDataPlane ): |
| """ Verifies /24 IP routing using ECMP -> L3U -> L2I """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| # Hashes Test Name and uses it as id for installing unique groups |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| vlan_id = port |
| id = port |
| # add l2 interface group |
| l2_gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, ecmp_msg.group_id ) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| Groups._put( ecmp_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:22:%02X' % in_port |
| ip_src = '192.168.%02d.1' % in_port |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % out_port |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=in_port, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| |
| @disabled |
| class MPLSBUG( base_tests.SimpleDataPlane ): |
| """ |
| Needs a description or needs to be removed |
| """ |
| def runTest( self ): |
| if len( config[ "port_map" ] ) < 2: |
| logging.info( "Port count less than 2, can't run this case" ) |
| return |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| Groups = Queue.LifoQueue( ) |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # add l2 interface group |
| vlan_id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| dst_mac[ 5 ] = vlan_id |
| # add L3 Unicast group |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_BOTH ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x08847, intf_src_mac, vlan_id, goto_table=24 ) |
| else: |
| add_termination_flow( self.controller, port, 0x8847, intf_src_mac, vlan_id, goto_table=24 ) |
| # add mpls flow |
| add_mpls_flow( self.controller, l3_msg.group_id, port ) |
| # add termination flow |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, l3_msg.group_id ) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| mac_src = '00:00:00:22:22:%02X' % in_port |
| ip_src = '192.168.%02d.1' % in_port |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % out_port |
| switch_mac = "00:00:00:cc:cc:cc" |
| label = (out_port, 0, 1, 32) |
| parsed_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=in_port, ip_src=ip_src, |
| ip_dst=ip_dst, eth_dst=switch_mac, eth_src=mac_src, label=[ label ] ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=31, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=in_port, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| |
| class L3McastToL3( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing, in this test case the traffic comes in tagged. |
| port+1 is used as ingress vlan_id. The packet goes out tagged on |
| different ports. 4094-port is used as egress vlan_id. |
| """ |
| def runTest( self ): |
| """ |
| port1 (vlan 300)-> All Ports (vlan 300) |
| """ |
| Groups = Queue.LifoQueue( ) |
| try: |
| # We can forward on the in_port but egress_vlan has to be different from ingress_vlan |
| if len( config[ "port_map" ] ) < 1: |
| logging.info( "Port count less than 1, can't run this case" ) |
| assert (False) |
| return |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| port_to_intf_src_mac_str, |
| Groups) = fill_mcast_pipeline_L3toL3( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = True, |
| is_egress_tagged = True, |
| is_vlan_translated = True, |
| is_max_vlan = False |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_in_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_out_vlan[out_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_intf_src_mac_str[out_port], |
| ip_ttl = 63, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| 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 ) |
| |
| @disabled |
| class L3McastToL2UntagToUntag( base_tests.SimpleDataPlane ): |
| """ |
| Fails on alternate runs |
| Mcast routing, in this test case the traffic is untagged. |
| 4094 is used as internal vlan_id. The packet goes out |
| untagged. |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = config[ "port_map" ].keys( ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = False, |
| is_egress_tagged = False, |
| is_vlan_translated = False, |
| is_max_vlan = True |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 L3McastToL2UntagToTag( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing, in this test case the traffic is untagged. |
| 300 is used as vlan_id. The packet goes out |
| tagged. |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = config[ "port_map" ].keys( ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = False, |
| is_egress_tagged = True, |
| is_vlan_translated = False, |
| is_max_vlan = False |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_out_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 L3McastToL2TagToUntag( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing, in this test case the traffic is tagged. |
| 300 is used as vlan_id. The packet goes out |
| untagged. |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = config[ "port_map" ].keys( ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = True, |
| is_egress_tagged = False, |
| is_vlan_translated = False, |
| is_max_vlan = False |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_in_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 L3McastToL2TagToTag( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing, in this test case the traffic is tagged. |
| 300 is used as vlan_id. The packet goes out tagged. |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = True, |
| is_egress_tagged = True, |
| is_vlan_translated = False, |
| is_max_vlan = False |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_in_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_in_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 L3McastToL2TagToTagTranslated( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing, in this test case the traffic is tagged. |
| port+1 is used as ingress vlan_id. The packet goes out |
| tagged. 4094-port is used as egress vlan_id |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = config[ "port_map" ].keys( ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| pair, |
| is_ingress_tagged = True, |
| is_egress_tagged = True, |
| is_vlan_translated = True, |
| is_max_vlan = False |
| ) |
| |
| for in_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_in_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in pair: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 100, |
| dl_vlan_enable = True, |
| vlan_vid = port_to_out_vlan[in_port], |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 ) |
| |
| @disabled |
| class L3McastTrafficThenDrop( base_tests.SimpleDataPlane ): |
| # fails on alternate repeated runs |
| """ |
| Mcast routing, in this test case the traffic is untagged. |
| 4094 is used as internal vlan_id. We first install aa full pipeline, |
| test that it forwards properly then remove all rules on table 40 and |
| mcast groups and ensure traffic is dropped. Blackhole of mcast traffic |
| if no tree is programmed on the switch. |
| """ |
| 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" ) |
| assert (False) |
| return |
| ports = config[ "port_map" ].keys( ) |
| dst_ip_str = "224.0.0.1" |
| ( |
| port_to_in_vlan, |
| port_to_out_vlan, |
| port_to_src_mac_str, |
| port_to_dst_mac_str, |
| port_to_src_ip, |
| port_to_src_ip_str, |
| Groups) = fill_mcast_pipeline_L3toL2( |
| self.controller, |
| logging, |
| ports, |
| is_ingress_tagged = False, |
| is_egress_tagged = False, |
| is_vlan_translated = False, |
| is_max_vlan = True |
| ) |
| |
| for in_port in ports: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in ports: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| 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 ) |
| |
| delete_all_flows_one_table(ctrl=self.controller, logger=logging, table_id=40); |
| delete_all_groups(self.controller) |
| |
| for in_port in ports: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| for out_port in ports: |
| |
| parsed_pkt = simple_udp_packet( |
| pktlen = 96, |
| eth_dst = port_to_dst_mac_str[in_port], |
| eth_src = port_to_src_mac_str[in_port], |
| ip_ttl = 64, |
| ip_src = port_to_src_ip_str[in_port], |
| ip_dst = dst_ip_str |
| ) |
| pkt = str( parsed_pkt ) |
| if out_port == in_port: |
| verify_no_packet( self, pkt, in_port ) |
| continue |
| verify_no_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 ) |
| |
| @disabled |
| class _MplsFwd( base_tests.SimpleDataPlane ): |
| """ Verify basic MPLS forwarding: Label switch router """ |
| |
| 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 |
| dip = 0xc0a80001 |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| # Assigns unique hardcoded test_id to make sure tests don't overlap when writing rules |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| vlan_id = port + 16 |
| mpls_label = port + 16 |
| |
| # add l2 interface group |
| id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| dst_mac[ 5 ] = port |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| vlan_id, id ) |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_SWAP_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=False, set_mpls_label=mpls_label, set_bos=1 ) |
| #ecmp_gid, ecmp_msg = add_mpls_forwarding_group( self.controller, |
| # subtype=OFDPA_MPLS_GROUP_SUBTYPE_ECMP, index=id, ref_gids=[mpls_label_gid] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x8847, intf_src_mac, vlan_id, goto_table=24 ) |
| else: |
| add_termination_flow( self.controller, port, 0x8847, intf_src_mac, vlan_id, goto_table=24 ) |
| #add_mpls_flow( self.controller, ecmp_gid, port, goto_table=29 ) |
| if config["switch_type"] != 'xpliant': |
| add_mpls_flow( self.controller, mpls_label_gid, mpls_label, goto_table=29 ) |
| else: |
| xpliant_add_mpls_flow( self.controller, mpls_label_gid, mpls_label, goto_table=29 ) |
| dst_ip = dip + (vlan_id << 8) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| #Groups._put( ecmp_gid ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| out_mpls_label = out_port + 16 |
| in_vlan_vid = in_port + 16 |
| out_vlan_vid = out_port + 16 |
| |
| ip_dst = '192.168.%02d.1' % (out_port) |
| label = (out_mpls_label, 0, 1, 32) |
| parsed_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(in_vlan_vid), |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=switch_mac, label=[ label ] ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| label = (out_mpls_label, 0, 1, 31) |
| exp_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(out_vlan_vid), |
| ip_src=ip_src, ip_dst=ip_dst, eth_src=switch_mac, eth_dst=mac_dst, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class _MplsTermination( base_tests.SimpleDataPlane ): |
| """ Verify MPLS VPN Termination at penultimate hop """ |
| |
| 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 |
| dip = 0xc0a80001 |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| # Assigns unique hardcoded test_id to make sure tests don't overlap when writing rules |
| ports = config[ "port_map" ].keys( ) |
| for port in ports: |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| vlan_id = port + 16 |
| mpls_label = port + 16 |
| |
| # add l2 interface group |
| id, dst_mac[ 5 ] = port, port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, port, vlan_id, True, False ) |
| # add L3 Unicast group |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add L3 ecmp group |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x8847, intf_src_mac, vlan_id, goto_table=24 ) |
| else: |
| add_termination_flow( self.controller, port, 0x8847, intf_src_mac, vlan_id, goto_table=24 ) |
| |
| if config["switch_type"] != 'xpliant': |
| add_mpls_flow( self.controller, ecmp_msg.group_id, mpls_label ) |
| else: |
| xpliant_add_mpls_flow( self.controller, ecmp_msg.group_id, mpls_label ) |
| |
| # add_mpls_flow(self.controller, label=port) |
| dst_ip = dip + (vlan_id << 8) |
| # add_unicast_routing_flow(self.controller, 0x0800, dst_ip, 0xffffff00, |
| # ecmp_msg.group_id, 1) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| Groups._put( ecmp_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in ports: |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in ports: |
| if in_port == out_port: |
| continue |
| |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| out_mpls_label = out_port + 16 |
| in_vlan_vid = in_port + 16 |
| out_vlan_vid = out_port + 16 |
| |
| ip_dst = '192.168.%02d.1' % (out_port) |
| label = (out_mpls_label, 0, 1, 32) |
| parsed_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(in_vlan_vid), |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=switch_mac, label=[ label ] ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| if config["switch_type"] != 'xpliant': |
| ip_ttl=31 |
| else: |
| ip_ttl=64 |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(out_vlan_vid), |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=ip_ttl, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| |
| @disabled |
| class One_MplsTermination( base_tests.SimpleDataPlane ): |
| """ |
| Verify MPLS VPN Termination at penultimate hop in only one direction |
| """ |
| |
| 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 |
| dip = 0xc0a80001 |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| # Assigns unique hardcoded test_id to make sure tests don't overlap when writing rules |
| ports = config[ "port_map" ].keys( ) |
| inport = ports[0] |
| outport = ports[1] |
| |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| invlan_id = inport + 16 |
| outvlan_id = outport + 16 |
| mpls_label = outport + 16 |
| |
| # add l2 interface group |
| id, dst_mac[ 5 ] = inport, outport |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, outport, outvlan_id, True, False ) |
| # add L3 Unicast group |
| l3_msg = add_l3_unicast_group( self.controller, outport, vlanid=outvlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add L3 ecmp group |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, inport, 1, invlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add tmac flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x8847, intf_src_mac, invlan_id, goto_table=24 ) |
| else: |
| add_termination_flow( self.controller, inport, 0x8847, intf_src_mac, invlan_id, goto_table=24 ) |
| # add mpls termination flow |
| add_mpls_flow( self.controller, ecmp_msg.group_id, mpls_label, send_barrier=True ) |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| time.sleep(0.1) |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| ip_src = '192.168.%02d.1' % (inport) |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| out_mpls_label = outport + 16 |
| in_vlan_vid = inport + 16 |
| out_vlan_vid = outport + 16 |
| |
| ip_dst = '192.168.%02d.1' % (outport) |
| label = (out_mpls_label, 0, 1, 32) |
| parsed_pkt = mpls_packet( pktlen=104, dl_vlan_enable=True, vlan_vid=(in_vlan_vid), |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=switch_mac, label=[ label ] ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( inport, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % (outport) |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(out_vlan_vid), |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=31, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, outport ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF__24UcastTagged_TC_0045( base_tests.SimpleDataPlane ): |
| """ Verify /24 IP forwarding to L3 Interface """ |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| test_id = 26 |
| if len( config[ "port_map" ] ) < 2: |
| logging.info( "Port count less than 2, can't run this case" ) |
| return |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| |
| for port in pair: |
| # add l2 interface group |
| vlan_id = port + test_id |
| l2gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| # def add_unicast_routing_flow(ctrl, eth_type, dst_ip, mask, action_group_id, vrf=0, send_ctrl=False, send_barrier=False, priority = 1): |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, l3_msg.group_id ) |
| Groups.put( l2gid ) |
| Groups.put( l3_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:22:%02X' % (test_id + in_port) |
| ip_src = '192.168.%02d.1' % (test_id + in_port) |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (test_id + out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + in_port), eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % (test_id + out_port) |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + out_port), eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| 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 _24UcastRouteBlackHole( base_tests.SimpleDataPlane ): |
| """ Verify black-holing of unicast routes, feature present only from OFDPA Premium 1.1.3.0""" |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| test_id = 27 |
| if len( config[ "port_map" ] ) < 2: |
| logging.info( "Port count less than 2, can't run this case" ) |
| return |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| # add l2 interface group |
| vlan_id = port + test_id |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| #dst ip = 10.0.0.0/8 |
| dst_ip = 0x0a000000 |
| add_unicast_blackhole_flow(self.controller, 0x0800, dst_ip, 0xffffff00 ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:22:%02X' % (test_id + in_port) |
| ip_src = '192.168.%02d.1' % (test_id + in_port) |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (test_id + out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + in_port), eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % (test_id + out_port) |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=(test_id + out_port), eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_no_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 _0Ucast( base_tests.SimpleDataPlane ): |
| """ Verify default gateway IP forwarding to L3 Interface ( /0 rule ) """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| # add l2 interface group |
| vlan_id = port |
| l2gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id + 1, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id + 1, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffffff, l3_msg.group_id, priority=2 ) |
| Groups.put( l2gid ) |
| Groups.put( l3_msg.group_id ) |
| l3_gid = encode_l3_unicast_group_id( pair[ 0 ] ) |
| dst_ip = 0x0 |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0x0, l3_gid ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| for in_port in pair: |
| mac_src = '00:00:00:22:22:%02X' % (in_port) |
| ip_src = '192.168.%02d.1' % (in_port) |
| for out_port in pair: |
| if in_port == out_port: |
| continue |
| ip_dst = '192.168.%02d.1' % (out_port) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(in_port), |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % (out_port) |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=(out_port + 1), |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| ip_dst = '1.168.%02d.1' % pair[ 0 ] |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=in_port, |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expect packet |
| mac_dst = '00:00:00:22:22:%02X' % pair[ 0 ] |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=ports[ 0 ] + 1, |
| ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst, eth_dst=mac_dst, eth_src=switch_mac ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, pair[ 0 ] ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class Unfiltered( base_tests.SimpleDataPlane ): |
| """ |
| Attempt to add an unfiltered group: [ATTENTION] this doesn't verify addition |
| """ |
| |
| def runTest( self ): |
| try: |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| vlan_id = 1; |
| for port in ports: |
| add_l2_unfiltered_group( self.controller, [ port ], False ) |
| do_barrier( self.controller ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class L3McastToVPN( base_tests.SimpleDataPlane ): |
| """ |
| Mcast routing and VPN initiation |
| """ |
| |
| def runTest( self ): |
| """ |
| port1 (vlan 1)-> port 2 (vlan 2) |
| """ |
| try: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| if len( config[ "port_map" ] ) < 3: |
| logging.info( "Port count less than 3, can't run this case" ) |
| assert (False) |
| return |
| |
| vlan_id = 1 |
| port2_out_vlan = 2 |
| port3_out_vlan = 3 |
| in_vlan = 1 # macast group vid shall use input vlan diffe from l3 interface use output vlan |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| intf_src_mac_str = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| dst_mac = [ 0x01, 0x00, 0x5e, 0x01, 0x01, 0x01 ] |
| dst_mac_str = ':'.join( [ '%02X' % x for x in dst_mac ] ) |
| port1_mac = [ 0x00, 0x11, 0x11, 0x11, 0x11, 0x11 ] |
| port1_mac_str = ':'.join( [ '%02X' % x for x in port1_mac ] ) |
| src_ip = 0xc0a80101 |
| src_ip_str = "192.168.1.1" |
| dst_ip = 0xe0010101 |
| dst_ip_str = "224.1.1.1" |
| |
| port1 = config[ "port_map" ].keys( )[ 0 ] |
| port2 = config[ "port_map" ].keys( )[ 1 ] |
| # port3=config["port_map"].keys()[2] |
| |
| # add l2 interface group |
| for port in config[ "port_map" ].keys( ): |
| add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, is_tagged=False, |
| send_barrier=False ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| vlan_id += 1 |
| |
| # add termination flow |
| add_termination_flow( self.controller, port1, 0x0800, [ 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 ], |
| vlan_id ) |
| |
| # add MPLS interface group |
| l2_gid = encode_l2_interface_group_id( port2_out_vlan, port2 ) |
| mpls_gid2, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dst_mac, intf_src_mac, |
| port2_out_vlan, port2 ) |
| # l2_gid3 = encode_l2_interface_group_id(port3_out_vlan, port3) |
| # mpls_gid3, mpls_msg = add_mpls_intf_group(self.controller, l2_gid3, dst_mac, intf_src_mac, port3_out_vlan, port3) |
| # add L3VPN groups |
| mpls_label_gid2, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=(0x20000 + port2), ref_gid=mpls_gid2, |
| push_mpls_header=True, set_mpls_label=port2, set_bos=1, cpy_ttl_outward=True ) |
| # mpls_label_gid3, mpls_label_msg = add_mpls_label_group(self.controller, subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, |
| # index=(0x10000+port3), ref_gid= mpls_gid3, push_mpls_header=True, set_mpls_label=port3, set_bos=1, cpy_ttl_outward=True) |
| |
| mcat_group_msg = add_l3_mcast_group( self.controller, in_vlan, 2, [ mpls_label_gid2 ] ) |
| add_mcast4_routing_flow( self.controller, in_vlan, src_ip, 0, dst_ip, mcat_group_msg.group_id ) |
| |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=1, eth_dst=dst_mac_str, |
| eth_src=port1_mac_str, ip_ttl=64, ip_src=src_ip_str, ip_dst=dst_ip_str ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( port1, pkt ) |
| label = (12, 0, 1, 63) |
| exp_pkt = mpls_packet( pktlen=100, eth_dst=dst_mac_str, eth_src=intf_src_mac_str, ip_ttl=64, |
| ip_src=src_ip_str, label=[ label ], ip_dst=dst_ip_str ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, port2 ) |
| # verify_packet(self, pkt, port3) |
| verify_no_other_packets( self ) |
| delete_all_groups( self.controller ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class PacketInSrcMacMiss( base_tests.SimpleDataPlane ): |
| """ |
| Test packet in function on a src-mac miss |
| Send a packet to each dataplane port and verify that a packet |
| in message is received from the controller for each |
| #todo verify you stop receiving after adding rule |
| """ |
| |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| ports = sorted( config[ "port_map" ].keys( ) ) |
| |
| Groups = Queue.LifoQueue( ) |
| for port in ports: |
| L2gid, l2msg = add_one_l2_interface_group( self.controller, port, 1, True, False ) |
| add_one_vlan_table_flow( self.controller, port, 1, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| Groups.put( L2gid ) |
| parsed_vlan_pkt = simple_tcp_packet( pktlen=104, vlan_vid=0x1001, dl_vlan_enable=True ) |
| vlan_pkt = str( parsed_vlan_pkt ) |
| for of_port in config[ "port_map" ].keys( ): |
| logging.info( "PacketInMiss test, port %d", of_port ) |
| self.dataplane.send( of_port, vlan_pkt ) |
| verify_packet_in( self, vlan_pkt, of_port, ofp.OFPR_NO_MATCH ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| |
| class FabricSW_OF_EcmpGroupMod_TC_0025( base_tests.SimpleDataPlane ): |
| """ |
| Verify referenced group can be modified by adding or removing buckets |
| """ |
| |
| 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 |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| # Hashes Test Name and uses it as id for installing unique groups |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| ecmp = [ ] |
| dst_ips = [] |
| # add flows for all ports but include only the egress switchport (connected to ports[1]) |
| # in the ecmp group |
| for port in pair: |
| vlan_id = port |
| id = port |
| # add l2 interface group |
| l2_gid, msg = add_one_l2_interface_group( self.controller, port, vlan_id=vlan_id, |
| is_tagged=True, send_barrier=False ) |
| dst_mac[ 5 ] = vlan_id |
| l3_msg = add_l3_unicast_group( self.controller, port, vlanid=vlan_id, id=id, |
| src_mac=intf_src_mac, dst_mac=dst_mac ) |
| if port == pair[1]: |
| ecmp += [ l3_msg.group_id ] |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, pair[ 0 ], [ l3_msg.group_id ] ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| dst_ip = dip + (vlan_id << 8) |
| dst_ips += [dst_ip] |
| Groups._put( ecmp_msg.group_id ) |
| mod_l3_ecmp_group( self.controller, pair[ 0 ], ecmp ) |
| for dst_ip in dst_ips: |
| add_unicast_routing_flow( self.controller, 0x0800, dst_ip, 0xffffff00, ecmp_msg.group_id ) |
| do_barrier(self.controller) |
| time.sleep(0.1) |
| # first part of the test: send packet from ingress switchport and expect it at egress switchport |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| parsed_pkt = exp_pkt = 0 |
| in_port = pair[0] |
| out_port = pair[1] |
| logging.info("\nSending packet to port: " + str(in_port) + ", expected egress on port: " + str(out_port)) |
| mac_src = '00:00:00:22:22:%02X' % pair[ 0 ] |
| ip_src = '192.168.%02d.%02d' % (pair[ 0 ], 1) |
| ip_dst = '192.168.%02d.%02d' % (pair[ 1 ], 1) |
| tcp = out_port if out_port == 24 else 25 |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=pair[ 0 ], |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, |
| ip_dst=ip_dst, tcp_dport=tcp ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( ports[ 0 ], pkt ) |
| # build expected packet at egress switchport |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, |
| ip_dst=ip_dst, tcp_dport=tcp ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| # second part of the test - edit the ecmp group to remove the orginal egress switchport |
| # and instead add the ingress switchport. Send packet from ingress switchport, and expect |
| # it back on the ingress switchport |
| l3_gid = encode_l3_unicast_group_id( pair[ 0 ] ) |
| mod_l3_ecmp_group( self.controller, pair[ 0 ], [ l3_gid ] ) |
| time.sleep(0.1) |
| logging.info("Sending packet to port: " + str(pair[0]) + ", expected egress on port: " + str(pair[0])) |
| mac_src = '00:00:00:22:22:%02X' % pair[ 0 ] |
| ip_src = '192.168.%02d.%02d' % (pair[ 0 ], 1) |
| ip_dst = '192.168.%02d.%02d' % (pair[ 1 ], 1) |
| tcp = port if port == 24 else 25 |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=pair[ 0 ], |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, |
| ip_dst=ip_dst,tcp_dport=tcp ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( pair[ 0 ], pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:%02X' % pair[ 0 ] |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=pair[ 0 ], |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, |
| ip_dst=ip_dst,tcp_dport=tcp ) |
| # Expects packet on the input port |
| if config["switch_type"] != 'xpliant': |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, pair[ 0 ] ) |
| verify_no_other_packets( self ) |
| |
| # third part of the test - edit the group to completely remove bucket. Packet sent |
| # should be dropped by the switch |
| mod_l3_ecmp_group( self.controller, pair[ 0 ], [ ] ) |
| time.sleep(0.1) |
| logging.info("Sending packet to port: " + str(pair[0]) + ", expected drop") |
| mac_src = '00:00:00:22:22:%02X' % pair[ 0 ] |
| ip_src = '192.168.%02d.%02d' % (pair[ 0 ], 1) |
| ip_dst = '192.168.%02d.%02d' % (pair[ 1 ], 1) |
| tcp = port if port == 24 else 25 |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=pair[ 0 ], |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, |
| ip_dst=ip_dst,tcp_dport=tcp ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( pair[ 0 ], pkt ) |
| verify_no_other_packets( self ) |
| |
| # final part of the test - edit the empty group to add back the bucket for the |
| # original egress port, and verify packet is received on egress switch port |
| l3_gid = encode_l3_unicast_group_id( pair[ 1 ] ) |
| mod_l3_ecmp_group( self.controller, pair[ 0 ], [ l3_gid ] ) |
| do_barrier(self.controller) |
| in_port = pair[0] |
| out_port = pair[1] |
| logging.info("Sending packet to port: " + str(in_port) + ", expected egress on port: " + str(out_port)) |
| mac_src = '00:00:00:22:22:%02X' % pair[ 0 ] |
| ip_src = '192.168.%02d.%02d' % (pair[ 0 ], 1) |
| ip_dst = '192.168.%02d.%02d' % (pair[ 1 ], 1) |
| tcp = out_port if out_port == 24 else 25 |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=pair[ 0 ], |
| eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, ip_src=ip_src, |
| ip_dst=ip_dst, tcp_dport=tcp ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( pair[ 0 ], pkt ) |
| # build expected packet at egress switchport |
| mac_dst = '00:00:00:22:22:%02X' % out_port |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=out_port, |
| eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, ip_src=ip_src, |
| ip_dst=ip_dst, tcp_dport=tcp ) |
| pkt = str( exp_pkt ) |
| 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 Untagged( base_tests.SimpleDataPlane ): |
| """ |
| Verify VLAN filtering table does not require OFPVID_PRESENT bit to be 0. |
| This should be fixed in OFDPA 2.0 GA and above, the test fails with |
| previous versions of the OFDPA. |
| |
| Two rules are necessary in VLAN table (10): |
| 1) Assignment: match 0x0000/(no mask), set_vlan_vid 0x100A, goto 20 |
| 2) Filtering: match 0x100A/0x1FFF, goto 20 |
| |
| In this test case vlan_id = (MAX_INTERNAL_VLAN - 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()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| vlan_id = Untagged.MAX_INTERNAL_VLAN - port |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| add_one_vlan_table_flow( self.controller, port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_UNTAG ) |
| for other_port in pair: |
| if other_port == port: |
| continue |
| L2gid, l2msg = add_one_l2_interface_group( self.controller, other_port, vlan_id, False, False ) |
| groups.put( L2gid ) |
| add_bridge_flow( self.controller, [ 0x00, 0x12, 0x34, 0x56, 0x78, other_port ], vlan_id, L2gid, True ) |
| |
| do_barrier( self.controller ) |
| |
| for out_port in pair: |
| # change dest based on port number |
| mac_dst = '00:12:34:56:78:%02X' % out_port |
| for in_port in pair: |
| if in_port == out_port: |
| continue |
| pkt = str( simple_tcp_packet( eth_dst=mac_dst ) ) |
| self.dataplane.send( in_port, pkt ) |
| for ofport in pair: |
| if ofport in [ out_port ]: |
| verify_packet( self, pkt, ofport ) |
| else: |
| verify_no_packet( self, pkt, ofport ) |
| verify_no_other_packets( self ) |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, groups ) |
| delete_all_groups( self.controller ) |
| |
| class MPLSSwapTest( base_tests.SimpleDataPlane ): |
| """ |
| MPLS switching with the same label used. |
| Used for interconnecting spines between different fabrics where |
| the label should not be popped, but swapepd with the same label. |
| """ |
| |
| def runTest( self ): |
| try: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| if len( config[ "port_map" ] ) < 2: |
| logging.info( "Port count less than 3, can't run this case" ) |
| assert (False) |
| return |
| |
| input_src_mac = [ 0x00, 0x00, 0x5e, 0x01, 0x01, 0x01 ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x5e, 0x01, 0x01, 0x02 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x5e, 0x01, 0x01, 0x03 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| mpls_label = 1000 |
| |
| src_ip = 0xc0a80101 |
| src_ip_str = "192.168.1.1" |
| dst_ip = 0xe0010101 |
| dst_ip_str = "224.1.1.1" |
| |
| src_port = config[ "port_map" ].keys( )[ 0 ] |
| dst_port = config[ "port_map" ].keys( )[ 1 ] |
| |
| out_vlan = 4094 |
| |
| add_one_l2_interface_group( self.controller, dst_port, vlan_id=out_vlan, is_tagged=False, |
| send_barrier=True ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, src_port, out_vlan_id=out_vlan, vlan_id=out_vlan, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| add_one_vlan_table_flow( self.controller, src_port, out_vlan_id=out_vlan, vlan_id=out_vlan, flag=VLAN_TABLE_FLAG_ONLY_UNTAG ) |
| |
| # add termination flow |
| |
| if config["switch_type"] == "qmx": |
| logging.debug("MPLSSwitching : Adding flow for qmx, without input port") |
| add_termination_flow( self.controller, 0, eth_type=0x08847, dst_mac=input_dst_mac, vlanid=out_vlan, goto_table=23) |
| else: |
| add_termination_flow( self.controller, in_port=src_port, |
| eth_type=0x8847, dst_mac=input_dst_mac, vlanid=out_vlan, goto_table=23) |
| |
| # add groups that will be used now |
| l2_gid = encode_l2_interface_group_id( out_vlan, dst_port) |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, |
| output_dst_mac, input_dst_mac, |
| out_vlan, dst_port, send_barrier=True) |
| index = 60 |
| mpls_swap_gid, mpls_swap_msg = add_mpls_swap_label_group( self.controller, mpls_gid, |
| 5, index, mpls_label) |
| |
| # add flow to mpls table |
| add_mpls_flow_swap( self.controller, mpls_swap_gid, mpls_label, 0x8847, 1, send_barrier=True) |
| |
| # we generate the packet which carries a single label |
| label = (mpls_label, 0, 1, 63) |
| parsed_pkt = mpls_packet( |
| pktlen=104, |
| label=[label], |
| eth_src=input_src_mac_str, |
| eth_dst=input_dst_mac_str, |
| ) |
| pkt = str( parsed_pkt ) |
| |
| self.dataplane.send( src_port, pkt ) |
| |
| label = (mpls_label, 0, 1, 62) |
| parsed_pkt = mpls_packet( |
| pktlen=104, |
| label=[label], |
| eth_src=input_dst_mac_str, |
| eth_dst=output_dst_mac_str, |
| ) |
| pkt = str( parsed_pkt ) |
| |
| verify_packet( self, pkt, dst_port ) |
| verify_no_packet( self, pkt, src_port ) |
| verify_no_other_packets( self ) |
| |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class DoubleToUntagged( base_tests.SimpleDataPlane ): |
| """ |
| Verify MPLS IP VPN Initiation from /24 rule using ECMP |
| where we receive double tagged packets and output untagged |
| packets. |
| |
| Each double tagged packet represents a subscriber where Outer tag is pon |
| and inner tag is the subrscriber tag. |
| """ |
| |
| 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 |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = 66 |
| outer_vlan = 77 |
| id = 10 |
| mpls_label = 152 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface group |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, out_port, inner_vlan, False, True ) |
| |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, output_dst_mac, input_dst_mac, |
| inner_vlan, id ) |
| |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=mpls_label, set_bos=1, set_ttl=32 ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ mpls_label_gid ] ) |
| |
| do_barrier( self.controller ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, outer_vlan, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_STACKED ) |
| |
| add_one_vlan_1_table_flow( self.controller, port, outer_vlan_id=outer_vlan, inner_vlan_id=inner_vlan, |
| flag=VLAN_TABLE_FLAG_ONLY_UNTAG ) |
| |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, input_dst_mac, inner_vlan ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, input_dst_mac, inner_vlan ) |
| |
| # add_unicast_routing_flow(self.controller, 0x0800, dst_ip, 0, mpls_label_gid, vrf=2) |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffff00, ecmp_msg.group_id, |
| vrf=0 ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| do_barrier( self.controller ) |
| |
| ip_src = '192.168.5.5' |
| ip_dst = '192.168.0.5' |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=inner_vlan, outer_vlan=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| |
| # print("Expected %s" % format_packet(pkt)) |
| |
| self.dataplane.send( port, pkt ) |
| |
| # build expect packet |
| label = (mpls_label, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=96, dl_vlan_enable=False, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=output_dst_mac_str, eth_src=input_dst_mac_str, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| @disabled |
| class DoubleToUntaggedMultipleSubscribers( base_tests.SimpleDataPlane ): |
| """ |
| Verify MPLS IP VPN Initiation from /24 rule using ECMP |
| where we receive double tagged packets and output untagged |
| packets. |
| |
| Each double tagged packet represents a subscriber where Outer tag is pon |
| and inner tag is the subrscriber tag. |
| """ |
| |
| 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 |
| |
| # each entry represents a subscriber [id, ip in hex, inner_vlan, outer_vlan, ip in dot form] |
| subscriber_info = [ [10, 0xc0a80001, 10, 100, "192.168.0.1"], |
| [20, 0xc0a80002, 10, 101, "192.168.0.2"], |
| [30, 0xc0a80003, 11, 100, "192.168.0.3"], |
| [40, 0xc0a80004, 11, 101, "192.168.0.4"]] |
| |
| print("") |
| |
| for sub_info in subscriber_info: |
| |
| print("Initializing rules for subscriber with id {0}".format(sub_info[0])) |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| id = 10 |
| mpls_label = 152 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface group |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, out_port, inner_vlan, False, True ) |
| |
| # add MPLS interface group |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, output_dst_mac, input_dst_mac, |
| inner_vlan, id ) |
| |
| # add MPLS L3 VPN group |
| mpls_label_gid, mpls_label_msg = add_mpls_label_group( self.controller, |
| subtype=OFDPA_MPLS_GROUP_SUBTYPE_L3_VPN_LABEL, index=id, ref_gid=mpls_gid, |
| push_mpls_header=True, set_mpls_label=mpls_label, set_bos=1, set_ttl=32 ) |
| ecmp_msg = add_l3_ecmp_group( self.controller, id, [ mpls_label_gid ] ) |
| |
| do_barrier( self.controller ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, outer_vlan, vrf=0, |
| flag=VLAN_TABLE_FLAG_ONLY_STACKED ) |
| |
| add_one_vlan_1_table_flow( self.controller, port, outer_vlan_id=outer_vlan, inner_vlan_id=inner_vlan, |
| flag=VLAN_TABLE_FLAG_ONLY_UNTAG ) |
| |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, input_dst_mac, inner_vlan ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, input_dst_mac, inner_vlan ) |
| |
| # add_unicast_routing_flow(self.controller, 0x0800, dst_ip, 0, mpls_label_gid, vrf=2) |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffff00, ecmp_msg.group_id, |
| vrf=0 ) |
| Groups._put( l2_gid ) |
| Groups._put( mpls_gid ) |
| Groups._put( mpls_label_gid ) |
| Groups._put( ecmp_msg.group_id ) |
| |
| do_barrier( self.controller ) |
| |
| for sub_info in subscriber_info: |
| |
| print("Sending packet for subscriber with id {0}".format(sub_info[0])) |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| id = 10 |
| mpls_label = 152 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| ip_src = sub_info[4] |
| ip_dst = '192.168.0.{}'.format(sub_info[0]) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, vlan_vid=inner_vlan, outer_vlan=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| |
| # print("Sent %s" % format_packet(pkt)) |
| |
| self.dataplane.send( port, pkt ) |
| |
| # build expect packet |
| label = (mpls_label, 0, 1, 32) |
| exp_pkt = mpls_packet( pktlen=96, dl_vlan_enable=False, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst, eth_dst=output_dst_mac_str, eth_src=input_dst_mac_str, |
| label=[ label ] ) |
| pkt = str( exp_pkt ) |
| 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 ) |
| |
| |
| @disabled |
| class UntaggedToDouble ( base_tests.SimpleDataPlane ): |
| """ |
| Verify google senario where we need to go from |
| an untagged packet to a double tagged packet. |
| |
| This is used for a single subscriber. |
| """ |
| |
| 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 |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = 66 |
| outer_vlan = 77 |
| id = 10 |
| mpls_label = 152 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 unfiltered interface group |
| l2_gid, l2_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| l3_msg = add_l3_unicast_group( self.controller, out_port, vlanid=4094, id=id, |
| src_mac=input_dst_mac, dst_mac=output_dst_mac, gid=l2_gid) |
| |
| do_barrier( self.controller ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, 4094, |
| flag=VLAN_TABLE_FLAG_ONLY_BOTH ) |
| |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, input_dst_mac, 4094 ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, input_dst_mac, 4094 ) |
| |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffffff, l3_msg.group_id, |
| vrf=0 ) |
| |
| add_one_egress_vlan_table_flow( self.controller, out_port, 4094 , inner_vlan, outer_vlan) |
| |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| |
| do_barrier( self.controller ) |
| |
| ip_src = '192.168.5.5' |
| ip_dst = '192.168.0.1' |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=False, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| |
| # print("Input Packet %s" % format_packet(pkt)) |
| |
| self.dataplane.send( port, pkt ) |
| |
| # build expect packet |
| exp_pkt = simple_tcp_packet( pktlen=108, dl_vlan_enable=True, vlan_vid=inner_vlan, outer_vlan=outer_vlan, |
| eth_dst=output_dst_mac_str, eth_src=input_dst_mac_str, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| |
| # print("Expected Packet %s" % format_packet(pkt)) |
| |
| 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 ) |
| |
| @disabled |
| class UntaggedToDoubleMultipleSubscribers ( base_tests.SimpleDataPlane ): |
| """ |
| Verify google senario where we need to go from |
| an untagged packet to a double tagged packet. |
| |
| This is used for multiple subscribers. |
| |
| However, this solution does not scale, since we assign an internal vlan to each subscriber |
| used in L3 Unicast Group in order to differentiate between them in the Egress Vlan 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 |
| |
| # each entry represents a subscriber [id, ip in hex, inner_vlan, outer_vlan, ip in dot form, internal vlan] |
| subscriber_info = [[1, 0xc0a80001, 10, 100, "192.168.0.1", 4000], |
| [2, 0xc0a80002, 10, 101, "192.168.0.2", 4001], |
| [3, 0xc0a80003, 11, 100, "192.168.0.3", 4002], |
| [4, 0xc0a80004, 11, 101, "192.168.0.4", 4003]] |
| |
| print("") |
| |
| for sub_info in subscriber_info: |
| |
| print("Initializing rules for subscriber with id {0}".format(sub_info[0])) |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| internal_vlan = sub_info[5] |
| id = sub_info[0] + 10 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 unfiltered interface group |
| l2_gid, l2_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| l3_msg = add_l3_unicast_group( self.controller, out_port, vlanid=internal_vlan, id=id, |
| src_mac=input_dst_mac, dst_mac=output_dst_mac, gid=l2_gid) |
| |
| do_barrier( self.controller ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, 4094, |
| flag=VLAN_TABLE_FLAG_ONLY_BOTH ) |
| |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, input_dst_mac, 4094 ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, input_dst_mac, 4094 ) |
| |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffffff, l3_msg.group_id, |
| vrf=0 ) |
| |
| add_one_egress_vlan_table_flow( self.controller, out_port, internal_vlan, inner_vlan, outer_vlan) |
| |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| for sub_info in subscriber_info: |
| |
| print("Sending packet for subscriber with id {0}".format(sub_info[0])) |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| internal_vlan = sub_info[5] |
| |
| id = sub_info[0] + 10 |
| ip_src = '192.168.5.5' |
| ip_dst = '192.168.0.{}'.format(sub_info[0]) |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=False, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| |
| # print("Input Packet %s" % format_packet(pkt)) |
| |
| self.dataplane.send( port, pkt ) |
| |
| # build expect packet |
| exp_pkt = simple_tcp_packet( pktlen=108, dl_vlan_enable=True, vlan_vid=inner_vlan, outer_vlan=outer_vlan, |
| eth_dst=output_dst_mac_str, eth_src=input_dst_mac_str, ip_ttl=63, ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| |
| # print("Expected Packet %s" % format_packet(pkt)) |
| |
| 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 ) |
| |
| @disabled |
| class UntaggedToDoubleChangeEthertype ( base_tests.SimpleDataPlane ): |
| |
| 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 |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = 0xc0a80001 |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = 66 |
| outer_vlan = 77 |
| id = 10 |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 unfiltered interface group |
| l2_gid, l2_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| l3_msg = add_l3_unicast_group( self.controller, out_port, vlanid=4094, id=id, |
| src_mac=input_dst_mac, dst_mac=output_dst_mac, gid=l2_gid) |
| |
| do_barrier( self.controller ) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, 1, 4094, |
| flag=VLAN_TABLE_FLAG_ONLY_BOTH ) |
| |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, input_dst_mac, 4094 ) |
| else: |
| add_termination_flow( self.controller, port, 0x0800, input_dst_mac, 4094 ) |
| |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffffff, l3_msg.group_id, |
| vrf=0 ) |
| |
| add_one_egress_vlan_table_flow( self.controller, out_port, 4094 , inner_vlan, outer_vlan) |
| |
| Groups._put( l2_gid ) |
| Groups._put( l3_msg.group_id ) |
| |
| # add vlan flow table |
| add_one_egress_vlan_tpid_table_flow( self.controller, out_port, outer_vlan+0x1000 ) |
| do_barrier( self.controller ) |
| |
| ip_src = '192.168.5.5' |
| ip_dst = '192.168.0.1' |
| parsed_pkt = simple_tcp_packet( pktlen=100, |
| dl_vlan_enable=False, |
| eth_dst=input_dst_mac_str, |
| eth_src=input_src_mac_str, |
| ip_ttl=64, |
| ip_src=ip_src, |
| ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| |
| print("Input Packet %s" % format_packet(pkt)) |
| |
| self.dataplane.send( port, pkt ) |
| |
| # build expect packet |
| exp_pkt = simple_tcp_packet_two_vlan( pktlen=108, |
| out_dl_vlan_enable=True, |
| out_vlan_vid=outer_vlan, |
| out_vlan_tpid=0x88a8, |
| in_dl_vlan_enable=True, |
| in_vlan_vid=inner_vlan, |
| eth_dst=output_dst_mac_str, |
| eth_src=input_dst_mac_str, |
| ip_ttl=63, |
| ip_src=ip_src, |
| ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| |
| print("Expected Packet %s" % format_packet(pkt)) |
| |
| 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 ) |
| |
| @disabled |
| class _MplsFwdInterfaceProblem_PW( base_tests.SimpleDataPlane ): |
| """ |
| Reproduces the pseudowire bug with the wrongly set destination mac address. |
| """ |
| def runTest( self ): |
| Groups = Queue.LifoQueue( ) |
| try: |
| if len( config[ "port_map" ] ) < 1: |
| logging.info( "Port count less than 1, can't run this case" ) |
| assert (False) |
| return |
| |
| macs_to_test = [( [ 0x00, 0x00, 0x00, 0x11, 0x11, 0x00 ], [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ], '00:00:00:11:11:00', '00:00:00:22:22:00'), |
| ( [ 0x00, 0x00, 0x00, 0x11, 0x22, 0x00 ], [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ], '00:00:00:11:22:00', '00:00:00:33:33:00'), |
| ( [ 0x00, 0x00, 0x00, 0x11, 0x33, 0x00 ], [ 0x00, 0x00, 0x00, 0x44, 0x44, 0x00 ], '00:00:00:11:33:00', '00:00:00:44:44:00'), |
| ( [ 0x00, 0x00, 0x00, 0x11, 0x44, 0x00 ], [ 0x00, 0x00, 0x00, 0x55, 0x55, 0x00 ], '00:00:00:11:44:00', '00:00:00:55:55:00'), |
| ( [ 0x00, 0x00, 0x00, 0x11, 0x55, 0x00 ], [ 0x00, 0x00, 0x00, 0x66, 0x66, 0x00 ], '00:00:00:11:55:00', '00:00:00:66:66:00')] |
| |
| for dummy_dst_mac, dst_mac, mac_dst_dummy, mac_dst in macs_to_test: |
| |
| dip = 0xc0a80001 |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| |
| out_port = 12 |
| port = 24 |
| # Shift MPLS label and VLAN ID by 16 to avoid reserved values |
| vlan_id = port + 16 |
| mpls_label = port + 16 |
| |
| in_port = 24 |
| ip_src = '192.168.%02d.1' % (in_port) |
| |
| # create dummy groups |
| id = port |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, out_port, vlan_id, False, False) |
| mpls_gid, mpls_msg = add_mpls_intf_group( self.controller, l2_gid, dummy_dst_mac, intf_src_mac, |
| vlan_id, id, send_barrier=True) |
| do_barrier( self.controller ) |
| |
| # PW Case. |
| raw_input("Press anything to move on with pseudowire rules, after that you should see the updated groups in the switch.") |
| logging.info("Installing entries for pseudowire!") |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| mpls_label = 100 |
| mpls_label_SR2 = 100 + 10 |
| mpls_label_PW = 100 + 15 |
| |
| print("Install MPLS intf group for dst mac {0}", dst_mac) |
| # add MPLS interface group |
| mpls_intf_gid, mpls_intf_msg = add_mpls_intf_group( |
| ctrl=self.controller, |
| ref_gid=l2_gid, |
| dst_mac=dst_mac, |
| src_mac=intf_src_mac, |
| vid=vlan_id, |
| index=id, |
| add=False, |
| send_barrier=True |
| ) |
| |
| # add MPLS flow with BoS=0 |
| add_mpls_flow_pw( |
| ctrl=self.controller, |
| action_group_id=mpls_intf_gid, |
| label=mpls_label_SR2, |
| ethertype=0x8847, |
| tunnel_index=1, |
| bos=0 |
| ) |
| |
| # add Termination flow |
| add_termination_flow( |
| ctrl=self.controller, |
| in_port=in_port, |
| eth_type=0x8847, |
| dst_mac=intf_src_mac, |
| vlanid=vlan_id, |
| goto_table=23 |
| ) |
| |
| # add VLAN flows |
| add_one_vlan_table_flow( |
| ctrl=self.controller, |
| of_port=in_port, |
| vlan_id=vlan_id, |
| flag=VLAN_TABLE_FLAG_ONLY_TAG, |
| ) |
| add_one_vlan_table_flow( |
| ctrl=self.controller, |
| of_port=in_port, |
| vlan_id=vlan_id, |
| flag=VLAN_TABLE_FLAG_ONLY_UNTAG |
| ) |
| # Packet generation with sleep |
| time.sleep(2) |
| label_SR2 = (mpls_label_SR2, 0, 0, 32) |
| label_2 = (mpls_label_PW, 0, 1, 32) |
| |
| # set to false to test if routing traffic |
| # comes through |
| raw_input("Press enter to send the packet, inspect the groups in the switch!") |
| print("Sending packet with dst mac {0} and labels {1}".format(switch_mac, [label_SR2, label_2])) |
| parsed_pkt = mpls_packet( |
| pktlen=104, |
| ip_ttl=63, |
| label=[label_SR2, label_2], |
| encapsulated_ethernet = True, |
| eth_dst=switch_mac |
| ) |
| |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| |
| expected_label = (mpls_label_PW, 0, 1, 31) |
| print("Expecting packet with dst mac {0} and labels {1}".format(mac_dst, [label_2])) |
| parsed_pkt = mpls_packet( |
| pktlen=100, |
| ip_ttl=63, |
| eth_dst=mac_dst, |
| eth_src=switch_mac, |
| label=[ expected_label ], |
| encapsulated_ethernet = True |
| ) |
| |
| pkt = str( parsed_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_packet( self, pkt, in_port ) |
| |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| class VlanCrossConnect ( base_tests.SimpleDataPlane ): |
| """ |
| Tries the cross connect functionality of the ofdpa switches. |
| """ |
| 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 |
| |
| # each entry represents a subscriber [id, ip in hex, inner_vlan, outer_vlan, ip in dot form] |
| subscriber_info = [ [10, 0xc0a80001, 12, 11, "192.168.0.1"] ] |
| |
| index = 5 |
| for sub_info in subscriber_info: |
| |
| #print("Initializing rules for subscriber with id {0}".format(sub_info[0])) |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| |
| index = inner_vlan |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface group, uncomment for unfiltered |
| l2_gid, l2_msg = add_one_l2_interface_group( self.controller, out_port, outer_vlan, True, True) |
| #i l2_gid, l2_msg = add_one_l2_unfiltered_group( self.controller, out_port, 1, True) |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, inner_vlan, outer_vlan, vrf=0, flag=VLAN_TABLE_FLAG_ONLY_STACKED ) |
| add_one_vlan_1_table_flow_pw( self.controller, port, index, new_outer_vlan_id=outer_vlan ,outer_vlan_id=outer_vlan, inner_vlan_id=inner_vlan, cross_connect=True, send_barrier=True) |
| add_mpls_l2_port_flow(ctrl=self.controller, of_port=port, mpls_l2_port=port, tunnel_index=index, ref_gid=l2_gid, qos_index=0, goto=ACL_FLOW_TABLE) |
| index += 1 |
| |
| Groups._put( l2_gid ) |
| do_barrier( self.controller ) |
| |
| for sub_info in subscriber_info: |
| #print("Sending packet for subscriber with id {0}".format(sub_info[0])) |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| |
| port = ports[0] |
| out_port = ports[1] |
| |
| ip_src = sub_info[4] |
| ip_dst = '192.168.0.{}'.format(sub_info[0]) |
| parsed_pkt = qinq_tcp_packet( pktlen=120, vlan_vid=inner_vlan, dl_vlan_outer=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| parsed_pkt = simple_tcp_packet_two_vlan( pktlen=120, out_dl_vlan_enable=True, in_dl_vlan_enable=True, in_vlan_vid=inner_vlan, out_vlan_vid=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| |
| pkt = str( parsed_pkt ) |
| |
| self.dataplane.send( port, pkt ) |
| 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 ) |
| |
| |
| @disabled |
| class Lag( base_tests.SimpleDataPlane ): |
| """ |
| Checks the L2 load balancing (LAG) functionality of the ofdpa switches. |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface unfiltered group |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| Groups.put(l2_o_gid, lag_gid) |
| |
| # --- TEST 1: bridging with load-bal---- |
| vlan_in_port_untagged = 31 |
| # table 10 flows and bridging flows for dstMac+vlan -> l2-load-bal group |
| add_one_vlan_table_flow( self.controller, in_port, vlan_id=vlan_in_port_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| mac_dst = [ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 ] |
| mac_dst_str = '00:11:22:33:44:55' |
| add_bridge_flow( self.controller, mac_dst, vlan_in_port_untagged, lag_gid, True ) |
| # untagged packet input becomes tagged packet at output |
| time.sleep(0.1) |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=mac_dst_str ) ) |
| exp_pkt = str( simple_tcp_packet( pktlen=84, dl_vlan_enable=True, vlan_vid=vlan_in_port_untagged, eth_dst=mac_dst_str ) ) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| # --- TEST 2: flooding with load-bal ---- |
| # flooding group --> load-bal group --> l2 unfiltered interface |
| floodmsg = add_l2_flood_group_with_gids( self.controller, [lag_gid] , vlan_in_port_untagged, id=0 ) |
| Groups.put( floodmsg.group_id ) |
| # add bridging flows for flooding groups |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_in_port_untagged, group_id=floodmsg.group_id ) |
| # unknown dstmac packet input to hit flood group |
| un_mac_dst_str = '00:11:22:ff:ff:ff' |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=un_mac_dst_str ) ) |
| exp_pkt = str( simple_tcp_packet( pktlen=84, dl_vlan_enable=True, vlan_vid=vlan_in_port_untagged, eth_dst=un_mac_dst_str ) ) |
| time.sleep(0.1) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| # --- TEST 3: editing load-bal ---- |
| # create and add another l2 unfiltered interface group to the load-balancing group |
| l2_i_gid, l2_i_msg = add_one_l2_unfiltered_group( self.controller, in_port, True) |
| msg = mod_l2_loadbal_group(self.controller, 1, [l2_o_gid, l2_i_gid], True) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| |
| # delete all buckets in loadbal group |
| msg = mod_l2_loadbal_group(self.controller, 1, [], True) |
| time.sleep(0.1) |
| self.dataplane.send( in_port, pkt ) |
| verify_no_other_packets( self ) # no buckets |
| |
| # only input port in load balancing group |
| msg = mod_l2_loadbal_group(self.controller, 1, [l2_i_gid], True) |
| self.dataplane.send( in_port, pkt ) |
| verify_no_other_packets( self ) # packet should not be sent out of in port |
| |
| # remove input port and add output port in lag group |
| msg = mod_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| time.sleep(0.1) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| #print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class FloodLb( base_tests.SimpleDataPlane ): |
| """ |
| Checks L2 flood group pointing to L2 load balance group with 2 buckets (unfiltered). |
| The packet from in_port should not be seen on the out_port |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| vlan_in_port_untagged = 31 |
| |
| # add l2 unfiltered interface group for outport |
| l2_i_gid, l2_i_msg = add_one_l2_unfiltered_group( self.controller, in_port, True) |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_i_gid, l2_o_gid], True) |
| |
| # create l2 flood group with mix of l2i and l2-loadbal |
| floodmsg = add_l2_flood_group_with_gids( self.controller, [lag_gid] , vlan_in_port_untagged, id=0, send_barrier=True ) |
| Groups.put( l2_i_gid ) |
| Groups.put( l2_o_gid ) |
| Groups.put( lag_gid ) |
| Groups.put( floodmsg.group_id ) |
| |
| # table 10 flows for untagged input |
| add_one_vlan_table_flow( self.controller, in_port, vlan_id=vlan_in_port_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| add_one_vlan_table_flow( self.controller, out_port, vlan_id=vlan_in_port_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| |
| # add bridging flows for flooding groups |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_in_port_untagged, group_id=floodmsg.group_id ) |
| # unknown dstmac packet will hit flood group |
| un_mac_dst_str = '00:11:22:ff:ff:ff' |
| |
| # check one direction -> packet enters through inport should not be seen on the outport |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=un_mac_dst_str ) ) |
| self.dataplane.send( in_port, pkt ) |
| verify_no_other_packets( self ) |
| |
| # check other direction -> packet enters through outport should not be seen on the inport |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=un_mac_dst_str ) ) |
| self.dataplane.send( out_port, pkt ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| #print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class FloodMixUntagged( base_tests.SimpleDataPlane ): |
| """ |
| Checks the combination of L2 filtered and L2 load balancing (LAG) groups |
| in a flooding group |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| vlan_in_port_untagged = 31 |
| |
| # add l2 unfiltered interface group for outport |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| |
| # create l2 interface (filtered) group for inport |
| l2_i_gid, l2_i_msg = add_one_l2_interface_group( self.controller, in_port, vlan_in_port_untagged, |
| is_tagged=False, send_barrier=True) |
| |
| # create l2 flood group with mix of l2i and l2-loadbal |
| floodmsg = add_l2_flood_group_with_gids( self.controller, [lag_gid, l2_i_gid] , vlan_in_port_untagged, id=0 ) |
| Groups.put( l2_o_gid ) |
| Groups.put( lag_gid ) |
| Groups.put( l2_i_gid ) |
| Groups.put( floodmsg.group_id ) |
| |
| # table 10 flows for untagged input |
| add_one_vlan_table_flow( self.controller, in_port, vlan_id=vlan_in_port_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| |
| # add bridging flows for flooding groups |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_in_port_untagged, group_id=floodmsg.group_id ) |
| # unknown dstmac packet will hit flood group |
| un_mac_dst_str = '00:11:22:ff:ff:ff' |
| |
| # check one direction -> packet enters through filtered port (inport) and exits through |
| # unfiltered port (outport) via the flood and lag groups |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=un_mac_dst_str ) ) |
| exp_pkt = str( simple_tcp_packet( pktlen=84, dl_vlan_enable=True, vlan_vid=vlan_in_port_untagged, eth_dst=un_mac_dst_str ) ) |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| # check other direction -> packet enters through unfiltered port (outport) and exits through |
| # filtered port (inport) via the flood group |
| add_one_vlan_table_flow( self.controller, out_port, vlan_id=vlan_in_port_untagged, flag=VLAN_TABLE_FLAG_ONLY_BOTH, |
| send_barrier=True) |
| pkt = str( simple_tcp_packet( pktlen=80, eth_dst=un_mac_dst_str ) ) |
| exp_pkt = pkt # ingress packet gets internal vlan 31 which gets popped at l2 interface group before egress |
| self.dataplane.send( out_port, pkt ) |
| verify_packet( self, exp_pkt, in_port ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class FloodMixTagged( base_tests.SimpleDataPlane ): |
| """ |
| Checks the combination of L2 filtered and L2 load balancing (LAG) groups |
| in a flooding group |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| vlan_in_port_untagged = 31 |
| |
| # add l2 unfiltered interface group for outport |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| |
| # create l2 interface (filtered) group for inport |
| l2_i_gid, l2_i_msg = add_one_l2_interface_group( self.controller, in_port, vlan_in_port_untagged, |
| is_tagged=True, send_barrier=True) |
| |
| # create l2 flood group with mix of l2i and l2-loadbal |
| floodmsg = add_l2_flood_group_with_gids( self.controller, [lag_gid, l2_i_gid] , vlan_in_port_untagged, id=0 ) |
| Groups.put( l2_o_gid ) |
| Groups.put( lag_gid ) |
| Groups.put( l2_i_gid ) |
| Groups.put( floodmsg.group_id ) |
| |
| # table 10 flows for tagged in_port. Note: VLAN in table 10 must be wildcarded for an unfiltered port |
| add_vlan_table_flow_allow_all_vlan(self.controller, in_port, send_barrier=True) |
| |
| # add bridging flows for flooding groups |
| add_bridge_flow( self.controller, dst_mac=None, vlanid=vlan_in_port_untagged, group_id=floodmsg.group_id ) |
| # unknown dstmac packet will hit flood group |
| un_mac_dst_str = '00:11:22:ff:ff:ff' |
| |
| # check one direction -> packet enters through unfiltered port (inport) and exits through |
| # unfiltered port (outport) via the flood and lag groups |
| pkt = str( simple_tcp_packet( pktlen=80, dl_vlan_enable=True, vlan_vid=vlan_in_port_untagged, eth_dst=un_mac_dst_str ) ) |
| exp_pkt = pkt |
| self.dataplane.send( in_port, pkt ) |
| verify_packet( self, exp_pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| # check other direction -> packet enters through unfiltered port (outport) and exits through |
| # unfiltered port (inport) via the flood group |
| |
| # table 10 flows for tagged out_port. Note: VLAN must be wildcarded for an unfiltered port |
| add_vlan_table_flow_allow_all_vlan(self.controller, out_port, send_barrier=True) |
| pkt = str( simple_tcp_packet( pktlen=80, dl_vlan_enable=True, vlan_vid=vlan_in_port_untagged, eth_dst=un_mac_dst_str ) ) |
| exp_pkt = pkt |
| self.dataplane.send( out_port, pkt ) |
| verify_packet( self, exp_pkt, in_port ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class LagMix( base_tests.SimpleDataPlane ): |
| """ |
| Checks the combination of L2 filtered and unfiltered interface groups |
| in a L2 load balancing (LAG) group - this should not work according to spec |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| vlan_in_port_untagged = 31 |
| |
| # add l2 unfiltered interface group |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 interface (filtered) group |
| l2_i_gid, l2_i_msg = add_one_l2_interface_group( self.controller, in_port, vlan_in_port_untagged, |
| is_tagged=False, send_barrier=True) |
| |
| # create l2 load-balance group with a mix of filtered and unfiltered groups |
| """ |
| XXX the following does not work - the group does not get created but curiously we don't get an openflow |
| error message. The ofdpa logs show |
| ofdbGroupBucketValidate: Referenced Group Id 0x1f000c not of type L2 Unfiltered Interface. |
| We do get an openflow error message for the flood group that follows because it cannot |
| find the lag group it points to (because it did not get created). |
| """ |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid, l2_i_gid], True) |
| |
| # create l2 flood group to point to lag group |
| floodmsg = add_l2_flood_group_with_gids( self.controller, [lag_gid] , vlan_in_port_untagged, id=0 ) |
| Groups.put( floodmsg.group_id, l2_i_gid, lag_gid ) |
| Groups.put( l2_o_gid ) |
| |
| finally: |
| #print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| |
| @disabled |
| class LagXconn( base_tests.SimpleDataPlane ): |
| """ |
| Checks the L2 load balancing (LAG) with vlan crossconnects. |
| Note that for this to work, basic VlanCrossConnect test above (without LAG) should work first |
| Note: this doesn't work on XGS or QMX yet with premium 1.1.7 |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface unfiltered group |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| Groups.put(l2_o_gid, lag_gid) |
| |
| # a subscriber [id, ip in hex, inner_vlan, outer_vlan, ip in dot form] |
| sub_info = [10, 0xc0a80001, 12, 11, "192.168.0.1"] |
| |
| input_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, sub_info[0] ] |
| input_src_mac_str = ':'.join( [ '%02X' % x for x in input_src_mac ] ) |
| input_dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| input_dst_mac_str = ':'.join( [ '%02X' % x for x in input_dst_mac ] ) |
| output_dst_mac = [ 0x00, 0x00, 0x00, 0x33, 0x33, 0x00 ] |
| output_dst_mac_str = ':'.join( [ '%02X' % x for x in output_dst_mac ] ) |
| |
| dip = sub_info[1] |
| ports = config[ "port_map" ].keys( ) |
| inner_vlan = sub_info[2] |
| outer_vlan = sub_info[3] |
| index = inner_vlan |
| port = ports[0] |
| out_port = ports[1] |
| |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, port, inner_vlan, outer_vlan, vrf=0, flag=VLAN_TABLE_FLAG_ONLY_STACKED ) |
| add_one_vlan_1_table_flow_pw( self.controller, port, index, new_outer_vlan_id=outer_vlan, outer_vlan_id=outer_vlan, |
| inner_vlan_id=inner_vlan, cross_connect=True, send_barrier=True) |
| """ |
| XXX The following flow in table 13 is rejected by the switch (qmx) probably due to the reference to lag group |
| ofdpa logs say: 08-22 00:43:10.344338 [ofstatemanager] Error from Forwarding while inserting flow: Unknown error |
| """ |
| add_mpls_l2_port_flow(ctrl=self.controller, of_port=port, mpls_l2_port=port, tunnel_index=index, ref_gid=lag_gid, |
| qos_index=0, goto=ACL_FLOW_TABLE) |
| do_barrier( self.controller ) |
| |
| ip_src = sub_info[4] |
| ip_dst = '192.168.0.{}'.format(sub_info[0]) |
| parsed_pkt = qinq_tcp_packet( pktlen=120, vlan_vid=inner_vlan, dl_vlan_outer=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| parsed_pkt = simple_tcp_packet_two_vlan( pktlen=120, out_dl_vlan_enable=True, in_dl_vlan_enable=True, |
| in_vlan_vid=inner_vlan, out_vlan_vid=outer_vlan, |
| eth_dst=input_dst_mac_str, eth_src=input_src_mac_str, |
| ip_ttl=64, ip_src=ip_src, ip_dst=ip_dst ) |
| |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( port, pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| #print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| @disabled |
| class LagRouting( base_tests.SimpleDataPlane ): |
| """ |
| Checks the L2 load balancing (LAG) with routing flows. |
| Specifically route -> L3Unicast -> Lag -> L2 Unfiltered interface |
| """ |
| 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( )) |
| in_port = ports[0] |
| out_port = ports[1] |
| |
| # add l2 interface unfiltered group |
| l2_o_gid, l2_o_msg = add_one_l2_unfiltered_group( self.controller, out_port, True) |
| |
| # create l2 load-balance group |
| lag_gid, lag_msg = add_l2_loadbal_group(self.controller, 1, [l2_o_gid], True) |
| Groups.put(l2_o_gid, lag_gid) |
| |
| intf_src_mac = [ 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc ] |
| dst_mac = [ 0x00, 0x00, 0x00, 0x22, 0x22, 0x00 ] |
| dip = 0xc0a80001 |
| vlan_id = 31 |
| |
| # create L3 Unicast group to point to Lag group |
| l3_msg = add_l3_unicast_group( self.controller, out_port, vlanid=vlan_id, id=vlan_id, |
| src_mac=intf_src_mac, dst_mac=dst_mac, gid=lag_gid ) |
| # add vlan flow table |
| add_one_vlan_table_flow( self.controller, in_port, 1, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG ) |
| # add termination flow |
| if config["switch_type"] == "qmx": |
| add_termination_flow( self.controller, 0, 0x0800, intf_src_mac, vlan_id ) |
| else: |
| add_termination_flow( self.controller, in_port, 0x0800, intf_src_mac, vlan_id ) |
| # add unicast routing flow |
| add_unicast_routing_flow( self.controller, 0x0800, dip, 0xffffffff, l3_msg.group_id ) |
| |
| Groups.put( l3_msg.group_id ) |
| do_barrier( self.controller ) |
| |
| switch_mac = ':'.join( [ '%02X' % x for x in intf_src_mac ] ) |
| mac_src = '00:00:00:22:22:%02X' % (in_port) |
| ip_src = '192.168.0.2' |
| ip_dst = '192.168.0.1' |
| parsed_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=vlan_id, eth_dst=switch_mac, eth_src=mac_src, ip_ttl=64, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( parsed_pkt ) |
| self.dataplane.send( in_port, pkt ) |
| # build expected packet |
| mac_dst = '00:00:00:22:22:00' |
| exp_pkt = simple_tcp_packet( pktlen=100, dl_vlan_enable=True, |
| vlan_vid=vlan_id, eth_dst=mac_dst, eth_src=switch_mac, ip_ttl=63, |
| ip_src=ip_src, ip_dst=ip_dst ) |
| pkt = str( exp_pkt ) |
| verify_packet( self, pkt, out_port ) |
| verify_no_other_packets( self ) |
| |
| finally: |
| #print("done") |
| delete_all_flows( self.controller ) |
| delete_groups( self.controller, Groups ) |
| delete_all_groups( self.controller ) |
| |
| class FabricSW_OF_EAPOL_TC_0060(base_tests.SimpleDataPlane): |
| """ |
| To verify double VLAN tagged EAPOL packets can be matched and sent to controller. |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_eapol = 0x888e |
| eth_type_non_eapol = 0x88ee |
| eth_type = 0x8100 |
| vlan_id100 = 100 |
| vlanid200 = 200 |
| |
| logging.info("Step 1") |
| logging.info("Add a flow to TABLE-10 to match VLAN ID '100' for packets received at Data Port 1 and action transition to TABLE-20.") |
| |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_eapol) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_eapol)) |
| |
| logging.info("Step 2") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_eapol))) |
| parsed_pkt = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_eapol, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt = str(parsed_pkt) |
| |
| logging.info("Step 3") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_non_eapol))) |
| parsed_pkt_non_eapol = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_non_eapol, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt_non_eapol = str(parsed_pkt_non_eapol) |
| |
| logging.info("Step 4") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_eapol), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| logging.info("Step 5") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_non_eapol), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt_non_eapol) |
| verify_no_packet_in(self, vlan_pkt_non_eapol, ports[0]) |
| |
| logging.info("Step 6 Cleanup flows") |
| delete_all_flows(self.controller) |
| time.sleep(1) |
| |
| logging.info("Step 7") |
| logging.info("Add flows again ID=10 and ID=60") |
| for port in pair: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_eapol) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_eapol)) |
| time.sleep(1) |
| |
| logging.info("Step 8") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_eapol), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| logging.info("End of Test") |
| |
| |
| |
| class FabricSW_OF_ARP_TC_0065(base_tests.SimpleDataPlane): |
| """ |
| To verify double VLAN tagged ARP packets can be matched and sent to controller. |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_arp = 0x806 |
| eth_type_non_arp = 0x888e |
| eth_type = 0x8100 |
| vlan_id100 = 100 |
| vlanid200 = 200 |
| |
| logging.info("Step 1") |
| logging.info("Add a flow to TABLE-10 to match VLAN ID '100' for packets received at Data Port 1 and action transition to TABLE-20.") |
| |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| for port in pair: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_arp) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_arp)) |
| |
| logging.info("Step 2") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_arp))) |
| parsed_pkt = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_arp, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt = str(parsed_pkt) |
| |
| logging.info("Step 3") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_non_arp))) |
| parsed_pkt_non_arp = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_non_arp, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt_non_arp = str(parsed_pkt_non_arp) |
| |
| logging.info("Step 4") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_arp), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| logging.info("Step 5") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_non_arp), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt_non_arp) |
| verify_no_packet_in(self, vlan_pkt_non_arp, ports[0]) |
| |
| logging.info("Step 6 Cleanup flows") |
| delete_all_flows(self.controller) |
| time.sleep(1) |
| |
| logging.info("Step 7") |
| logging.info("Add flows again ID=10 and ID=60") |
| for port in pair: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_arp) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_arp)) |
| time.sleep(1) |
| |
| logging.info("Step 8") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_arp), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| @disabled |
| class FabricSW_OF_ARP_LAG_TC(base_tests.SimpleDataPlane): |
| """ |
| To verify double VLAN tagged ARP packets received over a LAG interface can be matched and sent to controller. |
| |
| TODO: Need to add step: Create a logical port (LAG) and bind data ports 1 and 2 to the logical port. |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_arp = 0x806 |
| eth_type_non_arp = 0x888e |
| eth_type = 0x8100 |
| vlan_id100 = 100 |
| vlanid200 = 200 |
| |
| logging.info("Step 1") |
| logging.info( |
| "Create a logical port (LAG) and bind data ports 1 and 2 to the logical port.") |
| |
| # TODO: add LAG here: |
| |
| logging.info("Step 2") |
| logging.info("Add a flow to TABLE-10 to match VLAN ID '100' for packets received at Data Port 1 and action transition to TABLE-20.") |
| |
| ports = sorted(config["port_map"].keys()) |
| for port in ports: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_arp) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_arp)) |
| |
| logging.info("Step 3") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_arp))) |
| parsed_pkt = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_arp, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt = str(parsed_pkt) |
| |
| logging.info("Step 4") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_non_arp))) |
| parsed_pkt_non_eapol = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_non_arp, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt_non_eapol = str(parsed_pkt_non_eapol) |
| |
| logging.info("Step 5") |
| for port in ports: |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_arp), port)) |
| self.dataplane.send(port, vlan_pkt) |
| verify_packet_in(self, vlan_pkt, port, ofp.OFPR_ACTION) |
| |
| logging.info("Step 7") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_non_arp), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt_non_eapol) |
| verify_no_packet_in(self, vlan_pkt_non_eapol, ports[0]) |
| |
| logging.info("Step 8 Cleanup flows") |
| delete_all_flows(self.controller) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_arp)) |
| |
| logging.info("Step 9") |
| logging.info( |
| "Send double tagged vlan packet with ethernet type {} to port {}".format(hex(eth_type_arp), ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_no_packet_in(self, vlan_pkt, ports[0]) |
| |
| |
| finally: |
| delete_all_flows( self.controller ) |
| delete_all_groups( self.controller ) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_VLANPUSH_TC_0070(base_tests.SimpleDataPlane): |
| """ |
| To verify a VLAN tag can be pushed into an untagged packet received on a physical interface. |
| """ |
| |
| def runTest(self): |
| try: |
| vlan_id100 = 100 |
| ports = sorted(config["port_map"].keys()) |
| |
| logging.info("Step 1") |
| logging.info("Add a flow to TABLE-10 to match untagged packets received in Data Port 1 and immediate " |
| "action to insert VLAN tag {} and transition to TABLE-20.".format(vlan_id100)) |
| add_one_vlan_table_flow(ctrl=self.controller, of_port=ports[0], vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| add_one_vlan_table_flow(ctrl=self.controller, of_port=ports[0], vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_UNTAG) |
| |
| logging.info("Step 2") |
| logging.info("Add a flow to TABLE-60 to match VLAN tag {} and action Send to Controller".format(vlan_id100)) |
| add_acl_rule(ctrl=self.controller, vlan_id=vlan_id100) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id100)) |
| |
| logging.info("Step 3") |
| logging.info("Creating an untagged vlan packet") |
| parsed_pkt = simple_ether_packet_two_vlan(out_dl_vlan_enable=False, |
| in_dl_vlan_enable=False) |
| vlan_pkt = str(parsed_pkt) |
| |
| logging.info("Step 4") |
| logging.info("Send untagged packet to port {}".format(ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| logging.info("Step 6 Cleanup flows") |
| delete_all_flows(self.controller) |
| |
| logging.info("Step 5") |
| logging.info("Send untagged packet to port {}".format(ports[0])) |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_no_packet_in(self, vlan_pkt, ports[0]) |
| |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_LLDP_TC_0075(base_tests.SimpleDataPlane): |
| """ |
| To verify LLDP packets received on a physical interface can be matched and sent to Controller. |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_lldp = 0x88cc |
| eth_type_non_lldp = 0x88ee |
| |
| similar_steps(eth_type_lldp, eth_type_non_lldp, self) |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_BDDP_TC_0080(base_tests.SimpleDataPlane): |
| """ |
| To verify BDDP packets received on a physical interface can be matched and sent to Controller. |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_bddp = 0x8942 |
| eth_type_non_bddp = 0x888e |
| |
| similar_steps(eth_type_bddp, eth_type_non_bddp, self) |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_VLANXConnect_Single_TC_0085(base_tests.SimpleDataPlane): |
| """ |
| Verify QnQ traffic flooding between 2 cross (one-to-one) connected physical interfaces. |
| """ |
| |
| def runTest(self): |
| groups = Queue.LifoQueue() |
| try: |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 100 |
| vlan_id101 = 101 |
| |
| for port in pair: |
| L2gid, l2msg = add_one_l2_interface_group(self.controller, port, vlan_id, True, False) |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| groups.put(L2gid) |
| |
| msg = add_l2_flood_group(self.controller, pair, vlan_id, vlan_id) |
| groups.put(msg.group_id) |
| add_bridge_flow(self.controller, None, vlan_id, msg.group_id, True) |
| |
| #do_barrier(self.controller) |
| |
| logging.info( |
| "Add a flow to TABLE-60 to match vlan {} and action Send to Controller".format(vlan_id)) |
| add_acl_rule(self.controller, vlan_id=vlan_id) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id)) |
| |
| # verify flood |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id)) |
| for ofport in pair: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id, 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) |
| self.dataplane.send(ofport, pkt) |
| # self won't rx packet |
| verify_no_packet(self, pkt, ofport) |
| # others will rx packet |
| tmp_ports = list(pair) |
| tmp_ports.remove(ofport) |
| verify_packets(self, pkt, tmp_ports) |
| |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id101)) |
| mac_src = '00:12:34:56:78:%02X' % ports[0] |
| parsed_pkt_101 = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id101, in_dl_vlan_enable=True, in_vlan_vid=10, |
| eth_dst='00:12:34:56:78:9a', eth_src=mac_src) |
| |
| pkt_101 = str(parsed_pkt_101) |
| logging.info("Send double tugged packet to port {}".format(ports[0])) |
| self.dataplane.send(ports[0], pkt_101) |
| |
| logging.info("Verify the packet is not flooded to data port2 with outer vlan id {}".format(vlan_id101)) |
| verify_no_packet(self, pkt_101, ports[1]) |
| |
| logging.info("Cleanup flows") |
| delete_all_flows(self.controller) |
| |
| logging.info("Send double tugged packet to port {}".format(ports[1])) |
| self.dataplane.send(ports[1], pkt) |
| |
| logging.info("Verify the packet is not flooded to data port1 with outer vlan id {}".format(vlan_id)) |
| verify_no_packet(self, pkt, ports[0]) |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_groups(self.controller, groups) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_VLANXConnect_Multi_TC_0090(base_tests.SimpleDataPlane): |
| """ |
| Verify QnQ traffic flooding between Many-to-One (multiple S tags to single BNG) and One-Many (Single BNG to |
| multiple S tags) cross connected physical interfaces. |
| """ |
| |
| def runTest(self): |
| groups = Queue.LifoQueue() |
| try: |
| if len( config[ "port_map" ] ) < 4: |
| logging.info( "Port count less than 4, can't run this case" ) |
| assert (False) |
| return |
| ports = sorted(config["port_map"].keys()) |
| vlan_id100 = 100 |
| vlan_id101 = 101 |
| vlan_id102 = 102 |
| |
| # Create VLAN100 flow and tables for port1 and port4 |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[1]) |
| tmp_ports.remove(ports[2]) |
| |
| for port in tmp_ports: |
| L2gid, l2msg = add_one_l2_interface_group(self.controller, port, vlan_id100, True, False) |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| groups.put(L2gid) |
| |
| msg = add_l2_flood_group(self.controller, tmp_ports, vlan_id100, vlan_id100) |
| groups.put(msg.group_id) |
| add_bridge_flow(self.controller, None, vlan_id100, msg.group_id, True) |
| |
| # do_barrier(self.controller) |
| |
| logging.info( |
| "Add a flow to TABLE-60 to match vlan {} and action Send to Controller".format(vlan_id100)) |
| add_acl_rule(self.controller, vlan_id=vlan_id100) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id100)) |
| |
| # Create VLAN101 flow and tables for port2 and port4 |
| tmp_ports1 = list(ports) |
| tmp_ports1.remove(ports[0]) |
| tmp_ports1.remove(ports[2]) |
| |
| for port in tmp_ports1: |
| L2gid, l2msg = add_one_l2_interface_group(self.controller, port, vlan_id101, True, False) |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id101, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| groups.put(L2gid) |
| |
| msg = add_l2_flood_group(self.controller, tmp_ports1, vlan_id101, vlan_id101) |
| groups.put(msg.group_id) |
| add_bridge_flow(self.controller, None, vlan_id101, msg.group_id, True) |
| |
| # do_barrier(self.controller) |
| |
| logging.info( |
| "Add a flow to TABLE-60 to match vlan {} and action Send to Controller".format(vlan_id101)) |
| add_acl_rule(self.controller, vlan_id=vlan_id101) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id101)) |
| |
| # Create VLAN102 flow and tables for port3 and port4 |
| tmp_ports2 = list(ports) |
| tmp_ports2.remove(ports[0]) |
| tmp_ports2.remove(ports[1]) |
| |
| for port in tmp_ports2: |
| L2gid, l2msg = add_one_l2_interface_group(self.controller, port, vlan_id102, True, False) |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id102, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| groups.put(L2gid) |
| |
| msg = add_l2_flood_group(self.controller, tmp_ports2, vlan_id102, vlan_id102) |
| groups.put(msg.group_id) |
| add_bridge_flow(self.controller, None, vlan_id102, msg.group_id, True) |
| |
| # do_barrier(self.controller) |
| |
| logging.info( |
| "Add a flow to TABLE-60 to match vlan {} and action Send to Controller".format(vlan_id102)) |
| add_acl_rule(self.controller, vlan_id=vlan_id102) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id102)) |
| |
| |
| # verify flood VLAN100 from port1 to port4 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id100)) |
| for ofport in tmp_ports: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id100, 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) |
| self.dataplane.send(ofport, pkt) |
| # self won't rx packet |
| verify_no_packet(self, pkt, ofport) |
| # others will rx packet |
| tmp_ports.remove(ofport) |
| verify_packets(self, pkt, tmp_ports) |
| |
| # verify flood VLAN101 from port2 to port4 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id101)) |
| for ofport in tmp_ports1: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id101, 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) |
| self.dataplane.send(ofport, pkt) |
| # self won't rx packet |
| verify_no_packet(self, pkt, ofport) |
| # others will rx packet |
| tmp_ports1.remove(ofport) |
| verify_packets(self, pkt, tmp_ports1) |
| |
| # verify flood VLAN102 from port3 to port4 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id102)) |
| for ofport in tmp_ports2: |
| # change dest based on port number |
| mac_src = '00:12:34:56:78:%02X' % ofport |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id102, 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) |
| self.dataplane.send(ofport, pkt) |
| # self won't rx packet |
| verify_no_packet(self, pkt, ofport) |
| # others will rx packet |
| tmp_ports2.remove(ofport) |
| verify_packets(self, pkt, tmp_ports2) |
| |
| # verify flood VLAN101 to port1 - no receive on other ports |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id101)) |
| mac_src = '00:12:34:56:78:01' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id101, 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) |
| self.dataplane.send(ports[0], pkt) |
| # won't rx packet |
| verify_no_packet(self, pkt, ports[1]) |
| verify_no_packet(self, pkt, ports[2]) |
| verify_no_packet(self, pkt, ports[3]) |
| |
| # verify flood VLAN100 to port4 - receive on port1 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id100)) |
| mac_src = '00:12:34:56:78:04' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id100, 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) |
| self.dataplane.send(ports[3], pkt) |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[1]) |
| tmp_ports.remove(ports[2]) |
| tmp_ports.remove(ports[3]) |
| # rx packet on port1 |
| verify_packets(self, pkt, tmp_ports) |
| |
| # verify flood VLAN101 to port4 - receive on port2 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id101)) |
| mac_src = '00:12:34:56:78:04' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id101, 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) |
| self.dataplane.send(ports[3], pkt) |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[0]) |
| tmp_ports.remove(ports[2]) |
| tmp_ports.remove(ports[3]) |
| # rx packet on port1 |
| verify_packets(self, pkt, tmp_ports) |
| |
| # verify flood VLAN102 to port4 - receive on port3 |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id102)) |
| mac_src = '00:12:34:56:78:04' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id102, 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) |
| self.dataplane.send(ports[3], pkt) |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[0]) |
| tmp_ports.remove(ports[1]) |
| tmp_ports.remove(ports[3]) |
| # rx packet on port1 |
| verify_packets(self, pkt, tmp_ports) |
| |
| logging.info("Cleanup flows") |
| delete_all_flows(self.controller) |
| |
| # verify flood VLAN101 to port1 and port4 - no receive on any ports |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id100)) |
| mac_src = '00:12:34:56:78:01' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id100, 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) |
| self.dataplane.send(ports[0], pkt) |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[0]) |
| # won't rx packet |
| verify_no_packet(self, pkt, ports[1]) |
| verify_no_packet(self, pkt, ports[2]) |
| verify_no_packet(self, pkt, ports[3]) |
| |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id100)) |
| mac_src = '00:12:34:56:78:04' |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=108, out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id100, 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) |
| self.dataplane.send(ports[3], pkt) |
| tmp_ports = list(ports) |
| tmp_ports.remove(ports[3]) |
| # won't rx packet |
| verify_no_packet(self, pkt, ports[0]) |
| verify_no_packet(self, pkt, ports[1]) |
| verify_no_packet(self, pkt, ports[2]) |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_groups(self.controller, groups) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| class FabricSW_OF_Counters_TC_0095(base_tests.SimpleDataPlane): |
| """ |
| To verify the following port counters can be retrieved successfully from Open Flow switch: |
| rx_bytes_total, tx_bytes_total, rx_packets_total, tx_packets_total, rx_drop_packets_total, tx_drop_packets_total. |
| """ |
| |
| def runTest(self): |
| groups = Queue.LifoQueue() |
| try: |
| ports = sorted(config["port_map"].keys()) |
| pair = [ports[(1 - 1)], ports[(2 - 1)]] |
| vlan_id = 100 |
| vlan_len = 4 |
| num_pkts = 5 |
| pktlen = 108 |
| rx_bytes_expected = (pktlen + vlan_len) * num_pkts |
| rx_dropped_expected = 0 |
| tx_pkt_expected = num_pkts |
| tx_bytes_expected = rx_bytes_expected |
| tx_dropped_expected = 0 |
| |
| for port in pair: |
| L2gid, l2msg = add_one_l2_interface_group(self.controller, port, vlan_id, True, False) |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| groups.put(L2gid) |
| |
| msg = add_l2_flood_group(self.controller, pair, vlan_id, vlan_id) |
| groups.put(msg.group_id) |
| add_bridge_flow(self.controller, None, vlan_id, msg.group_id, True) |
| |
| # do_barrier(self.controller) |
| |
| logging.info("Add a flow to TABLE-60 to match vlan {}".format(vlan_id)) |
| add_acl_rule(self.controller, vlan_id=vlan_id) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.vlan_vid(vlan_id)) |
| |
| # Send Port_Stats request for the ingress port (retrieve old counter state) |
| initial_stats_rx = get_port_stats(self, ports[0]) |
| initial_stats_tx = get_port_stats(self, ports[1]) |
| |
| time.sleep(2) |
| logging.info("Get required counter values from port".format(ports[0])) |
| rx_bytes_before = get_required_statistic_from_port(self, ports[0], "rx_bytes") |
| rx_pkts_before = get_required_statistic_from_port(self, ports[0], "rx_packets") |
| rx_dropped_before = get_required_statistic_from_port(self, ports[0], "rx_dropped") |
| tx_bytes_before = get_required_statistic_from_port(self, ports[1], "tx_bytes") |
| tx_packets_before = get_required_statistic_from_port(self, ports[1], "tx_packets") |
| tx_dropped_before = get_required_statistic_from_port(self, ports[1], "tx_dropped") |
| |
| logging.info("Creating a double tagged vlan packet with outer vlan id {}".format(vlan_id)) |
| parsed_pkt = simple_tcp_packet_two_vlan(pktlen=pktlen, |
| out_dl_vlan_enable=True, |
| out_vlan_vid=vlan_id, |
| in_dl_vlan_enable=True, |
| in_vlan_vid=10, |
| eth_dst='00:12:34:56:78:9a') |
| pkt = str(parsed_pkt) |
| |
| logging.info("Send double tugged packets to port {}".format(ports[0])) |
| for pkt_cnt in range(num_pkts): |
| self.dataplane.send(ports[0], pkt) |
| |
| logging.info("Verify transmitted_packet counters") |
| verify_port_stats(self, ports[0], initial=initial_stats_rx, rx_pkts=num_pkts) |
| verify_port_stats(self, ports[1], initial=initial_stats_tx, tx_pkts=num_pkts) |
| |
| logging.info("Get required counter values from port after sending packets".format(ports[0])) |
| rx_bytes_after = get_required_statistic_from_port(self, ports[0], "rx_bytes") |
| rx_pkts_after = get_required_statistic_from_port(self, ports[0], "rx_packets") |
| rx_dropped_after = get_required_statistic_from_port(self, ports[0], "rx_dropped") |
| tx_bytes_after = get_required_statistic_from_port(self, ports[1], "tx_bytes") |
| tx_packets_after = get_required_statistic_from_port(self, ports[1], "tx_packets") |
| tx_dropped_after = get_required_statistic_from_port(self, ports[1], "tx_dropped") |
| |
| logging.info("Verify values incremented as expected on port".format(ports[0])) |
| self.assertGreaterEqual(rx_pkts_after - rx_pkts_before, num_pkts, |
| "Port RX packet counter is not updated as expected: {}, current value: {}".format(num_pkts, rx_pkts_after - rx_pkts_before)) |
| self.assertGreaterEqual(rx_bytes_after - rx_bytes_before, rx_bytes_expected, |
| "Port RX bytes counter is not updated as expected: {}, current value: {}".format(rx_bytes_expected, rx_bytes_after - rx_bytes_before)) |
| self.assertGreaterEqual(rx_dropped_after - rx_dropped_before, rx_dropped_expected, |
| "Port RX dropped counter is not updated as expected: {}, current value: {}".format(rx_dropped_expected, rx_dropped_after - rx_dropped_before)) |
| |
| self.assertEqual(tx_packets_after - tx_packets_before, tx_pkt_expected, |
| "Port TX packet counter is not updated as expected: {}, current value: {}".format(tx_pkt_expected, tx_packets_after - tx_packets_before)) |
| self.assertEqual(tx_bytes_after - tx_bytes_before, tx_bytes_expected, |
| "Port TX bytes counter is not updated as expected: {}, current value: {}".format(tx_bytes_expected, tx_bytes_after - tx_bytes_before)) |
| self.assertEqual(tx_dropped_after - tx_dropped_before, tx_dropped_expected, |
| "Port TX dropped counter is not updated as expected: {}, current value: {}".format(tx_dropped_expected, tx_dropped_after - tx_dropped_before)) |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_groups(self.controller, groups) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |
| |
| |
| def similar_steps(eth_type, not_expected_eth_type, self): |
| """ |
| Similar steps for tests: FabricSW_OF_BDDP_TC_0020 and FabricSW_OF_LLDP_TC_0015 |
| parameters: |
| @param eth_type matched ethernet type |
| @param not_expected_eth_type not matched ethernet type |
| @param self class instance |
| """ |
| |
| ports = sorted(config["port_map"].keys()) |
| |
| logging.info("Step 1") |
| logging.info( |
| "Add a flow to TABLE-60 to match Ethernet Type to {} and action Send to Controller".format(eth_type)) |
| add_acl_rule(self.controller, eth_type=eth_type) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type)) |
| |
| logging.info("Step 2") |
| logging.info("Creating an untagged packet with ethernet type {}".format(hex(eth_type))) |
| parsed_pkt = simple_eth_packet(eth_type=eth_type) |
| eth_pkt = str(parsed_pkt) |
| |
| logging.info("Step 3") |
| logging.info("Creating an untagged packet with ethernet type {}".format(hex(not_expected_eth_type))) |
| parsed_pkt_not_expected = simple_eth_packet(eth_type=not_expected_eth_type) |
| eth_pkt_non_lldp = str(parsed_pkt_not_expected) |
| |
| logging.info("Step 4") |
| logging.info( |
| "Send untagged packet with ethernet type {} to port {}".format(hex(eth_type), ports[0])) |
| self.dataplane.send(ports[0], eth_pkt) |
| verify_packet_in(self, eth_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| logging.info("Step 5") |
| logging.info( |
| "Send untagged packet with ethernet type {} to port {}".format(hex(not_expected_eth_type), ports[0])) |
| self.dataplane.send(ports[0], eth_pkt_non_lldp) |
| verify_no_packet_in(self, eth_pkt_non_lldp, ports[0]) |
| |
| logging.info("Step 6 Cleanup flows") |
| delete_all_flows(self.controller) |
| time.sleep(1) |
| |
| logging.info("Step 7") |
| logging.info( |
| "Send untagged packet with ethernet type {} to port {}".format(hex(eth_type), ports[0])) |
| self.dataplane.send(ports[0], eth_pkt) |
| verify_no_packet_in(self, eth_pkt, ports[0]) |
| |
| |
| @disabled |
| class test_interface_flap(base_tests.SimpleDataPlane): |
| """ |
| This is pilot test case to verify interface flap |
| """ |
| |
| def runTest(self): |
| try: |
| eth_type_eapol = 0x888e |
| eth_type = 0x8100 |
| vlan_id100 = 100 |
| vlanid200 = 200 |
| |
| logging.info("Step 1") |
| logging.info( |
| "Add a flow to TABLE-10 to match VLAN ID '100' for packets received at Data Port 1 and action transition to TABLE-20.") |
| |
| ports = sorted(config["port_map"].keys()) |
| for port in ports: |
| add_one_vlan_table_flow(self.controller, port, vlan_id=vlan_id100, flag=VLAN_TABLE_FLAG_ONLY_TAG) |
| |
| add_acl_rule(self.controller, eth_type=eth_type_eapol) |
| |
| match = ofp.match() |
| match.oxm_list.append(ofp.oxm.eth_type(eth_type_eapol)) |
| |
| logging.info("Step 2") |
| logging.info("Creating a double tagged vlan packet with ethernet type {}".format(hex(eth_type_eapol))) |
| parsed_pkt = simple_ether_packet_two_vlan(out_dl_vlan_enable=True, |
| in_dl_vlan_enable=True, |
| out_vlan_tpid=eth_type, |
| in_vlan_tpid=eth_type_eapol, |
| out_vlan_vid=vlan_id100, |
| in_vlan_vid=vlanid200) |
| vlan_pkt = str(parsed_pkt) |
| |
| logging.info("Step 4") |
| logging.info("Send untagged packet to port {}".format(ports[0])) |
| |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| print("") |
| print("flapping interface") |
| self.dataplane.port_down(ports[0]) |
| |
| time.sleep(2) |
| |
| print("bring up interface") |
| self.dataplane.port_up(ports[0]) |
| |
| self.dataplane.send(ports[0], vlan_pkt) |
| verify_packet_in(self, vlan_pkt, ports[0], ofp.OFPR_ACTION) |
| |
| |
| finally: |
| delete_all_flows(self.controller) |
| delete_all_groups(self.controller) |
| logging.info("End of Test") |