| |
| # 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. |
| |
| |
| """
|
| Flow Test
|
|
|
| Test each flow table can set entry, and packet rx correctly.
|
| """
|
|
|
| import logging
|
|
|
| from oftest import config
|
| import oftest.base_tests as base_tests
|
| import ofp
|
| from oftest.testutils import *
|
| from accton_util import *
|
|
|
| class L2McastFlow(base_tests.SimpleDataPlane):
|
| """
|
| Test output function for an exact-match flow
|
|
|
| Add some multicast flows
|
| Then, for all ports, verifies that sending a matching packet
|
| to a multicast match results in an output to all ports.
|
| """
|
| def runTest(self):
|
| ports = sorted(config["port_map"].keys())
|
|
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| # table 10: vlan
|
| # send to table 20
|
| add_vlan_table_flow(self.controller, config["port_map"].keys(), 1)
|
|
|
| # group table
|
| # set up untag groups for each port
|
| add_l2_interface_grouop(self.controller, config["port_map"].keys(), 1, False, False)
|
|
|
| # set up multicast group
|
| add_l2_mcast_group(self.controller, config["port_map"].keys(), 1, 1)
|
|
|
| test_macs = [[0x01, 0x00, 0x5e, 0x0f, 0xff, 0xff]]
|
|
|
| for test_mac in test_macs:
|
| group_id = encode_l2_mcast_group_id(1, 1)
|
| add_bridge_flow(self.controller, test_mac, 1, group_id, True)
|
|
|
| for test_mac in test_macs:
|
| mactest = ':'.join(['%02X' % x for x in test_mac])
|
|
|
| for in_port in ports:
|
| # change dest based on port number
|
| parsed_pkt = simple_tcp_packet(eth_dst=mactest)
|
| pkt = str(parsed_pkt)
|
| logging.info("OutputExact test, from port %d to mac %s", in_port, mactest)
|
| self.dataplane.send(in_port, pkt)
|
|
|
| for ofport in ports:
|
| if ofport == in_port: #tx port won't rx packet, unless L3 mcast routing
|
| continue
|
| verify_packet(self, pkt, ofport)
|
| verify_no_other_packets(self)
|
|
|
| class L2UnicastFlow(base_tests.SimpleDataPlane):
|
| """
|
| Test output function for an exact-match flow
|
|
|
| For each port A, adds a flow directing matching packets to that port.
|
| Then, for all other ports B != A, verifies that sending a matching packet
|
| to B results in an output to A.
|
| """
|
| def runTest(self):
|
| ports = sorted(config["port_map"].keys())
|
|
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
| # table 10: vlan
|
| # send to table 20
|
| #add_vlan_table_flow(self.controller, config["port_map"].keys(),1)
|
|
|
| # group table
|
| # set up tag groups for each port
|
| add_l2_interface_group(self.controller, config["port_map"].keys(), 1, True, 1)
|
|
|
| for port in ports:
|
| add_one_vlan_table_flow(self.controller, port, 1)
|
| 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)
|
|
|
| for out_port in ports:
|
| # 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:79:%02X' % in_port
|
| parsed_pkt = simple_tcp_packet(dl_vlan_enable=True, vlan_vid=1, eth_dst=mac_dst, eth_src=mac_src)
|
| pkt = str(parsed_pkt)
|
| logging.info("OutputExact test, ports %d to %d", in_port, out_port)
|
| 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 L2Flood(base_tests.SimpleDataPlane):
|
| """
|
| Test L2 unknown unicast flooding and broadcast flood
|
| """
|
| def runTest(self):
|
| ports = sorted(config["port_map"].keys())
|
|
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
| # table 10: vlan
|
| # send to table 20
|
| add_vlan_table_flow(self.controller, ports, 1)
|
|
|
| # group table
|
| # set up untag groups for each port
|
| add_l2_interface_grouop(self.controller, ports, 1, False, 1)
|
|
|
| input_port = ports.pop()
|
| flood_ports= ports
|
|
|
| #no fllod group create, veriy all drop
|
| parsed_pkt = simple_tcp_packet(eth_dst='00:12:34:56:78:9a')
|
| pkt = str(parsed_pkt)
|
| self.dataplane.send(input_port, pkt)
|
| verify_no_other_packets(self)
|
| parsed_pkt = simple_tcp_packet(eth_dst='FF:FF:FF:FF:FF:FF')
|
| pkt = str(parsed_pkt)
|
| self.dataplane.send(input_port, pkt)
|
| verify_no_other_packets(self)
|
| #add flood groupo
|
| msg=add_l2_flood_group(self.controller, flood_ports, 1, 1)
|
| add_bridge_flow(self.controller, None, 1, msg.group_id, True)
|
| #verify flood
|
| parsed_pkt = simple_tcp_packet(eth_dst='00:12:34:56:78:9a')
|
| pkt = str(parsed_pkt)
|
| self.dataplane.send(input_port, pkt)
|
| for ofport in flood_ports:
|
| verify_packet(self, pkt, ofport)
|
|
|
| verify_no_other_packets(self)
|
|
|
| for ofport in flood_ports:
|
| self.dataplane.send(ofport, pkt)
|
| #self won't rx packet
|
| verify_no_packet(self, pkt, ofport)
|
| #others will rx packet
|
| tmp_ports=[]
|
| for tmp in flood_ports:
|
| if tmp != ofport:
|
| tmp_ports.append(tmp)
|
| verify_packets(self, pkt, tmp_ports)
|
|
|
| verify_no_other_packets(self)
|
|
|
| parsed_pkt = simple_tcp_packet(eth_dst='FF:FF:FF:FF:FF:FF')
|
| pkt = str(parsed_pkt)
|
| self.dataplane.send(input_port, pkt)
|
| for ofport in flood_ports:
|
| verify_packet(self, pkt, ofport)
|
|
|
| class PacketInMiss(base_tests.SimpleDataPlane):
|
| """
|
| Test packet in function for a table-miss flow
|
|
|
| Send a packet to each dataplane port and verify that a packet
|
| in message is received from the controller for each
|
|
|
| NOTE: Verify This case the oft option shall not use --switch-ip
|
| """
|
|
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100)
|
| parsed_vlan_pkt = simple_tcp_packet(pktlen=104,
|
| vlan_vid=0x1001, dl_vlan_enable=True)
|
| pkt = str(parsed_pkt)
|
| vlan_pkt = str(parsed_vlan_pkt)
|
| # table 10: vlan
|
| # send to table 20
|
| add_vlan_table_flow(self.controller, config["port_map"].keys(), 1)
|
|
|
| # group table
|
| # set up untag groups for each port
|
| add_l2_interface_grouop(self.controller, config["port_map"].keys(), 1, False, 1)
|
|
|
| # create match
|
| match = ofp.match()
|
| match.oxm_list.append(ofp.oxm.vlan_vid(0x1001))
|
| 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, pkt)
|
|
|
| #AOS current packet in will not have vlan tag
|
| if config["cicada_poject"]:
|
| verify_packet_in(self, vlan_pkt, of_port, ofp.OFPR_ACTION)
|
| else:
|
| verify_packet_in(self, pkt, of_port, ofp.OFPR_ACTION)
|
|
|
| verify_no_other_packets(self)
|
|
|
| class PacketOut(base_tests.SimpleDataPlane):
|
| """
|
| Verify action Flood, ALL, in port
|
| """
|
|
|
| def runTest(self):
|
| if config["cicada_poject"]:
|
| pass
|
|
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100)
|
| parsed_vlan_pkt = simple_tcp_packet(pktlen=104,
|
| vlan_vid=0x1002, dl_vlan_enable=True)
|
|
|
| pkt = str(parsed_pkt)
|
| vlan_pkt = str(parsed_vlan_pkt)
|
|
|
|
|
| #packet out flood, untag packet
|
| self.controller.message_send(ofp.message.packet_out(in_port=ofp.OFPP_CONTROLLER,
|
| buffer_id=ofp.OFP_NO_BUFFER,
|
| actions=[ofp.action.output(
|
| port=ofp.OFPP_FLOOD)],
|
| data=pkt))
|
|
|
| for of_port in config["port_map"].keys():
|
| verify_packet(self, pkt, of_port)
|
|
|
| verify_no_other_packets(self)
|
|
|
| #packet out flood, tag packet, because it can't identify vlan has which port
|
| #so we do as all action.
|
| self.controller.message_send(ofp.message.packet_out(in_port=ofp.OFPP_CONTROLLER,
|
| buffer_id=ofp.OFP_NO_BUFFER,
|
| actions=[ofp.action.output(
|
| port=ofp.OFPP_FLOOD)],
|
| data=vlan_pkt))
|
|
|
| for of_port in config["port_map"].keys():
|
| verify_packet(self, vlan_pkt, of_port)
|
|
|
| verify_no_other_packets(self)
|
|
|
| #packet out all
|
| self.controller.message_send(ofp.message.packet_out(in_port=ofp.OFPP_CONTROLLER,
|
| buffer_id=ofp.OFP_NO_BUFFER,
|
| actions=[ofp.action.output(
|
| port=ofp.OFPP_FLOOD)],
|
| data=pkt))
|
|
|
| for of_port in config["port_map"].keys():
|
| verify_packet(self, pkt, of_port)
|
|
|
| verify_no_other_packets(self)
|
|
|
| #packet out to in port
|
| in_port = config["port_map"].keys()[0]
|
| self.controller.message_send(ofp.message.packet_out(in_port=in_port,
|
| buffer_id=ofp.OFP_NO_BUFFER,
|
| actions=[ofp.action.output(
|
| port=in_port)],
|
| data=pkt))
|
|
|
| verify_packet(self, pkt, in_port)
|
| verify_no_other_packets(self)
|
|
|
| class L3UcastRoute(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port2(vlan2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| """
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| if len(config["port_map"]) <2:
|
| logging.info("Port count less than 2, can't run this case")
|
| return
|
|
|
| vlan_id=1
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| dst_mac=[0x00, 0x00, 0x00, 0x22, 0x22, 0x00]
|
| dip=0xc0a80001
|
| for port in config["port_map"].keys():
|
| #add l2 interface group
|
| add_one_l2_interface_group(self.controller, port, vlan_id=vlan_id, is_tagged=False, 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, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
| #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, 0, l3_msg.group_id)
|
| vlan_id += 1
|
|
|
| do_barrier(self.controller)
|
|
|
| port1=config["port_map"].keys()[0]
|
| port2=config["port_map"].keys()[1]
|
| #port 1 to port 2
|
| switch_mac = ':'.join(['%02X' % x for x in intf_src_mac])
|
| dst_mac[5]=1
|
| port1_mac=':'.join(['%02X' % x for x in dst_mac])
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=port1_mac,
|
| ip_ttl=64,
|
| ip_src="192.168.1.1",
|
| ip_dst='192.168.2.1')
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port1, pkt)
|
| #build expect packet
|
| dst_mac[5]=2
|
| port2_mac=':'.join(['%02X' % x for x in dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port2_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src="192.168.1.1",
|
| ip_dst='192.168.2.1')
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port2)
|
| verify_no_other_packets(self)
|
|
|
| #port 2 to port 1
|
| switch_mac = ':'.join(['%02X' % x for x in intf_src_mac])
|
| dst_mac[5]=2
|
| port2_mac=':'.join(['%02X' % x for x in dst_mac])
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=port2_mac,
|
| ip_ttl=64,
|
| ip_src="192.168.2.1",
|
| ip_dst='192.168.1.1')
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port2, pkt)
|
| #build expect packet
|
| dst_mac[5]=1
|
| port1_mac=':'.join(['%02X' % x for x in dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port1_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src="192.168.2.1",
|
| ip_dst='192.168.1.1')
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port1)
|
| verify_no_other_packets(self)
|
|
|
| class L3UcastRouteOnSamVLANSamPort(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| """
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
| port = config["port_map"].keys()[0]
|
|
|
| vlan_id=1
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| port_mac1=[0x00, 0x00, 0x00, 0x22, 0x22, 0x01]
|
| port_mac2=[0x00, 0x00, 0x00, 0x22, 0x22, 0x02]
|
| port_ip1=0xc0a80101
|
| port_ip1_str=convertIP4toStr(port_ip1)
|
| port_ip2=0xc0a80201
|
| port_ip2_str=convertIP4toStr(port_ip2)
|
| #add l2 interface group
|
| 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_BOTH)
|
| #add termination flow
|
| add_termination_flow(self.controller, port, 0x0800, intf_src_mac, vlan_id)
|
|
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vlan_id, id=1, src_mac=intf_src_mac, dst_mac=port_mac2)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip2, 0, l3_msg.group_id)
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vlan_id, id=2, src_mac=intf_src_mac, dst_mac=port_mac1)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip1, 0, l3_msg.group_id)
|
|
|
| do_barrier(self.controller)
|
|
|
| """send packet to verify"""
|
| """192.168.1.1->192.168.2.1"""
|
| switch_mac_str = convertMACtoStr(intf_src_mac)
|
| port_mac1_str = convertMACtoStr(port_mac1)
|
| port_mac2_str = convertMACtoStr(port_mac2)
|
| ttl=64
|
| #send packet
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac1_str,
|
| ip_ttl=ttl,
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac2_str,
|
| eth_src=switch_mac_str,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| """192.168.2.1->192.168.1.1"""
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac2_str,
|
| ip_ttl=ttl,
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac1_str,
|
| eth_src=switch_mac_str,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| class L3UcastRouteOnDiffVLANSamPort(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port1(vlan2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| """
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
| port = config["port_map"].keys()[0]
|
|
|
| port_vlan_id1=1
|
| port_vlan_id2=2
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| port_mac1=[0x00, 0x00, 0x00, 0x22, 0x22, 0x01]
|
| port_mac2=[0x00, 0x00, 0x00, 0x22, 0x22, 0x02]
|
| port_ip1=0xc0a80101
|
| port_ip1_str=convertIP4toStr(port_ip1)
|
| port_ip2=0xc0a80201
|
| port_ip2_str=convertIP4toStr(port_ip2)
|
| #add l2 interface group
|
| add_one_l2_interface_group(self.controller, port, vlan_id=port_vlan_id1, is_tagged=True, send_barrier=False)
|
| add_one_l2_interface_group(self.controller, port, vlan_id=port_vlan_id2, is_tagged=True, send_barrier=False)
|
| #add vlan flow table
|
| add_one_vlan_table_flow(self.controller, port, port_vlan_id1, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
| add_one_vlan_table_flow(self.controller, port, port_vlan_id2, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
| #add termination flow
|
| add_termination_flow(self.controller, port, 0x0800, intf_src_mac, port_vlan_id1)
|
| add_termination_flow(self.controller, port, 0x0800, intf_src_mac, port_vlan_id2)
|
|
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=port_vlan_id2, id=1, src_mac=intf_src_mac, dst_mac=port_mac2)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip2, 0, l3_msg.group_id)
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=port_vlan_id1, id=2, src_mac=intf_src_mac, dst_mac=port_mac1)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip1, 0, l3_msg.group_id)
|
|
|
| do_barrier(self.controller)
|
|
|
| """send packet to verify"""
|
| """192.168.1.1->192.168.2.1"""
|
| switch_mac_str =convertMACtoStr(intf_src_mac)
|
| port_mac1_str= convertMACtoStr(port_mac1)
|
| port_mac2_str= convertMACtoStr(port_mac2)
|
| ttl=64
|
| #send packet
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac1_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=port_vlan_id1,
|
| ip_ttl=ttl,
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac2_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=port_vlan_id2,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| """192.168.2.1->192.168.1.1"""
|
| switch_mac = convertMACtoStr(intf_src_mac)
|
| port_mac2_str=convertMACtoStr(port_mac2)
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac2_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=port_vlan_id2,
|
| ip_ttl=ttl,
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac1_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=port_vlan_id1,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| class L3UcastVrfRouteOnSamVLANSamPort(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, VRF1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port1(vlan1, VRF1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| Port1(vlan2, VRF2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port1(vlan2, VRF2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
|
|
| """
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
| port = config["port_map"].keys()[0]
|
|
|
| vrf1=1
|
| vrf2=2
|
| vrf1_vlan_id=1
|
| vrf2_vlan_id=2
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| port_mac1=[0x00, 0x00, 0x00, 0x22, 0x22, 0x01]
|
| port_mac2=[0x00, 0x00, 0x00, 0x22, 0x22, 0x02]
|
| port_ip1=0xc0a80101
|
| port_ip1_str=convertIP4toStr(port_ip1)
|
| port_ip2=0xc0a80201
|
| port_ip2_str=convertIP4toStr(port_ip2)
|
| #add l2 interface group
|
| add_one_l2_interface_group(self.controller, port, vlan_id=vrf1_vlan_id, is_tagged=True, send_barrier=False)
|
| add_one_l2_interface_group(self.controller, port, vlan_id=vrf2_vlan_id, is_tagged=True, send_barrier=False)
|
| #add vlan flow table
|
| add_one_vlan_table_flow(self.controller, port, vrf1_vlan_id, vrf=vrf1, flag=VLAN_TABLE_FLAG_ONLY_TAG)
|
| add_one_vlan_table_flow(self.controller, port, vrf2_vlan_id, vrf=vrf2, flag=VLAN_TABLE_FLAG_ONLY_TAG)
|
|
|
| #add termination flow
|
| add_termination_flow(self.controller, 0, 0x0800, intf_src_mac, vrf1_vlan_id)
|
| add_termination_flow(self.controller, 0, 0x0800, intf_src_mac, vrf2_vlan_id)
|
|
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vrf1_vlan_id, id=1, src_mac=intf_src_mac, dst_mac=port_mac2)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip2, 0, l3_msg.group_id, vrf1)
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vrf2_vlan_id, id=2, src_mac=intf_src_mac, dst_mac=port_mac2)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip2, 0, l3_msg.group_id, vrf2)
|
|
|
| """192.168.1.1->192.168.2.1"""
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vrf1_vlan_id, id=3, src_mac=intf_src_mac, dst_mac=port_mac1)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip1, 0, l3_msg.group_id, vrf1)
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vrf2_vlan_id, id=4, src_mac=intf_src_mac, dst_mac=port_mac1)
|
| add_unicast_routing_flow(self.controller, 0x0800, port_ip1, 0, l3_msg.group_id, vrf2)
|
|
|
| do_barrier(self.controller)
|
|
|
| """send packet to verify on VRF vrf1"""
|
| """192.168.1.1->192.168.2.1"""
|
| switch_mac_str = convertMACtoStr(intf_src_mac)
|
| port_mac1_str = convertMACtoStr(port_mac1)
|
| port_mac2_str = convertMACtoStr(port_mac2)
|
| ttl=64
|
| #send packet
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac1_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf1_vlan_id,
|
| ip_ttl=ttl,
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac2_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf1_vlan_id,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| """192.168.2.1->192.168.1.1"""
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac2_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf1_vlan_id,
|
| ip_ttl=ttl,
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac1_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf1_vlan_id,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
|
|
| """send packet to verify on VRF vrf2"""
|
| """192.168.1.1->192.168.2.1"""
|
| switch_mac_str = convertMACtoStr(intf_src_mac)
|
| port_mac1_str = convertMACtoStr(port_mac1)
|
| port_mac2_str = convertMACtoStr(port_mac2)
|
| ttl=64
|
| #send packet
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac1_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf2_vlan_id,
|
| ip_ttl=ttl,
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac2_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf2_vlan_id,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip1_str,
|
| ip_dst=port_ip2_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
| """192.168.2.1->192.168.1.1"""
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac_str,
|
| eth_src=port_mac2_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf2_vlan_id,
|
| ip_ttl=ttl,
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port, pkt)
|
| #build expect packet
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port_mac1_str,
|
| eth_src=switch_mac_str,
|
| dl_vlan_enable=True,
|
| vlan_vid=vrf2_vlan_id,
|
| ip_ttl=(ttl-1),
|
| ip_src=port_ip2_str,
|
| ip_dst=port_ip1_str)
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port)
|
| verify_no_other_packets(self)
|
|
|
|
|
|
|
|
|
| class L3UcastECMP(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port2(vlan2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| """
|
| def runTest(self):
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| if len(config["port_map"]) <2:
|
| logging.info("Port count less than 2, can't run this case")
|
| return
|
|
|
| vlan_id=1
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| dst_mac=[0x00, 0x00, 0x00, 0x22, 0x22, 0x00]
|
| dip=0xc0a80001
|
| for port in config["port_map"].keys():
|
| #add l2 interface group
|
| add_one_l2_interface_group(self.controller, port, vlan_id=vlan_id, is_tagged=False, 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)
|
| ecmp_msg=add_l3_ecmp_group(self.controller, vlan_id, [l3_msg.group_id])
|
| #add vlan flow table
|
| add_one_vlan_table_flow(self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
| #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)
|
| #ECMP shall have prefix not 32
|
| add_unicast_routing_flow(self.controller, 0x0800, dst_ip, 0xffffff00, ecmp_msg.group_id)
|
| vlan_id += 1
|
|
|
| do_barrier(self.controller)
|
|
|
| port1=config["port_map"].keys()[0]
|
| port2=config["port_map"].keys()[1]
|
| #port 1 to port 2
|
| switch_mac = ':'.join(['%02X' % x for x in intf_src_mac])
|
| dst_mac[5]=1
|
| port1_mac=':'.join(['%02X' % x for x in dst_mac])
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=port1_mac,
|
| ip_ttl=64,
|
| ip_src="192.168.1.1",
|
| ip_dst='192.168.2.1')
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port1, pkt)
|
| #build expect packet
|
| dst_mac[5]=2
|
| port2_mac=':'.join(['%02X' % x for x in dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port2_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src="192.168.1.1",
|
| ip_dst='192.168.2.1')
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port2)
|
| verify_no_other_packets(self)
|
|
|
| #port 2 to port 1
|
| switch_mac = ':'.join(['%02X' % x for x in intf_src_mac])
|
| dst_mac[5]=2
|
| port2_mac=':'.join(['%02X' % x for x in dst_mac])
|
|
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=port2_mac,
|
| ip_ttl=64,
|
| ip_src="192.168.2.1",
|
| ip_dst='192.168.1.1')
|
| pkt=str(parsed_pkt)
|
| self.dataplane.send(port2, pkt)
|
| #build expect packet
|
| dst_mac[5]=1
|
| port1_mac=':'.join(['%02X' % x for x in dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=port1_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src="192.168.2.1",
|
| ip_dst='192.168.1.1')
|
| pkt=str(exp_pkt)
|
| verify_packet(self, pkt, port1)
|
| verify_no_other_packets(self)
|
|
|
|
|
| class L3UcastECMP2(base_tests.SimpleDataPlane):
|
| """
|
| Port1(vlan1, 0x00, 0x00, 0x00, 0x22, 0x22, 0x01, 192.168.1.1) ,
|
| Port2(vlan2, 0x00, 0x00, 0x00, 0x22, 0x22, 0x02, 19.168.2.1)
|
| Portn(vlann, 0x00, 0x00, 0x00, 0x22, 0x22, 0x0n, 19.168.n.1)
|
| """
|
|
|
| def runTest(self):
|
| 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")
|
| return
|
|
|
| vlan_id=1
|
| intf_src_mac=[0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc]
|
| same_dst_mac=[0x00, 0x00, 0x00, 0x22, 0x22, 0x22]
|
|
|
| l3_ucast_gips=[]
|
| tx_port = config["port_map"].keys()[0]
|
| for port in config["port_map"].keys():
|
| #add l2 interface group
|
| add_one_l2_interface_group(self.controller, port, vlan_id=vlan_id, is_tagged=False, send_barrier=False)
|
| if tx_port != port:
|
| l3_msg=add_l3_unicast_group(self.controller, port, vlanid=vlan_id, id=vlan_id, src_mac=intf_src_mac, dst_mac=same_dst_mac)
|
| l3_ucast_gips.append(l3_msg.group_id)
|
| #add vlan flow table
|
| add_one_vlan_table_flow(self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
| #add termination flow
|
| add_termination_flow(self.controller, port, 0x0800, intf_src_mac, vlan_id)
|
| vlan_id += 1
|
|
|
| tx_dip=0x0a0a0a0a
|
| tx_sip=0x0b0a0a0a
|
| ecmp_msg=add_l3_ecmp_group(self.controller, vlan_id, l3_ucast_gips)
|
| #ECMP shall have prefix not 32
|
| add_unicast_routing_flow(self.controller, 0x0800, tx_dip, 0xffffff00, ecmp_msg.group_id)
|
|
|
| do_barrier(self.controller)
|
|
|
| switch_mac = ':'.join(['%02X' % x for x in intf_src_mac])
|
| packet_src_mac="00:00:33:44:55:66"
|
| #from unknown src ip to unknown dst ip, to verify ecmp
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=packet_src_mac,
|
| ip_ttl=64,
|
| ip_src=convertIP4toStr(tx_sip),
|
| ip_dst=convertIP4toStr(tx_dip))
|
| self.dataplane.send(tx_port, str(parsed_pkt))
|
| #build expect packet
|
| dst_mac=':'.join(['%02X' % x for x in same_dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=dst_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src=convertIP4toStr(tx_sip),
|
| ip_dst=convertIP4toStr(tx_dip))
|
|
|
| verify_packet(self, exp_pkt, config["port_map"].keys()[2])
|
| verify_no_other_packets(self)
|
| tx_sip=tx_sip+0x01000000
|
| #from unknown scr ip to unknown dst ip, to verify ecmp
|
| parsed_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=switch_mac,
|
| eth_src=packet_src_mac,
|
| ip_ttl=64,
|
| ip_src=convertIP4toStr(tx_sip),
|
| ip_dst=convertIP4toStr(tx_dip))
|
| self.dataplane.send(tx_port, str(parsed_pkt))
|
| #build expect packet
|
| dst_mac=':'.join(['%02X' % x for x in same_dst_mac])
|
| exp_pkt = simple_tcp_packet(pktlen=100,
|
| eth_dst=dst_mac,
|
| eth_src=switch_mac,
|
| ip_ttl=63,
|
| ip_src=convertIP4toStr(tx_sip),
|
| ip_dst=convertIP4toStr(tx_dip))
|
|
|
| verify_packet(self, exp_pkt, config["port_map"].keys()[1])
|
| verify_no_other_packets(self)
|
|
|
| class L3McastRoute1(base_tests.SimpleDataPlane):
|
| """
|
| Mcast routing, From VLAN 1 to VLAN 2
|
| """
|
| def runTest(self):
|
| """
|
| port1 (vlan 1)-> port 2 (vlan 2)
|
| """
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| if len(config["port_map"]) <3:
|
| logging.info("Port count less than 2, can't run this case")
|
| 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_BOTH)
|
| vlan_id +=1
|
|
|
| #add termination flow
|
| add_termination_flow(self.controller, port1, 0x0800, [0x01, 0x00, 0x5e, 0x00, 0x00, 0x00], vlan_id)
|
|
|
| #add l3 interface group
|
| port2_ucast_msg=add_l3_interface_group(self.controller, port2, port2_out_vlan, 2, intf_src_mac)
|
| port3_ucast_msg=add_l3_interface_group(self.controller, port3, port3_out_vlan, 3, intf_src_mac)
|
| mcat_group_msg=add_l3_mcast_group(self.controller, in_vlan, 2, [port2_ucast_msg.group_id, port3_ucast_msg.group_id])
|
| add_mcast4_routing_flow(self.controller, in_vlan, src_ip, 0, dst_ip, mcat_group_msg.group_id)
|
|
|
| parsed_pkt = simple_udp_packet(pktlen=100,
|
| 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)
|
| parsed_pkt = simple_udp_packet(pktlen=100,
|
| eth_dst=dst_mac_str,
|
| eth_src=intf_src_mac_str,
|
| ip_ttl=63,
|
| ip_src=src_ip_str,
|
| ip_dst=dst_ip_str)
|
| pkt=str(parsed_pkt)
|
| verify_packet(self, pkt, port2)
|
| verify_packet(self, pkt, port3)
|
| verify_no_other_packets(self)
|
|
|
| class L3McastRoute2(base_tests.SimpleDataPlane):
|
| """
|
| Mcast routing, but on same vlan (l2mcast)
|
| """
|
| def runTest(self):
|
| """
|
| port1 (vlan 1)-> port 2 (vlan 1)
|
| """
|
| delete_all_flows(self.controller)
|
| delete_all_groups(self.controller)
|
|
|
| if len(config["port_map"]) <2:
|
| logging.info("Port count less than 2, can't run this case")
|
| return
|
|
|
| vlan_id =1
|
| 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]
|
|
|
|
|
| #add l2 interface group
|
| l2_intf_group_list=[]
|
| for port in config["port_map"].keys():
|
| if port != port1 and port !=port2:
|
| continue
|
| l2_intf_gid, msg=add_one_l2_interface_group(self.controller, port, vlan_id=vlan_id, is_tagged=False, send_barrier=False)
|
| l2_intf_group_list.append(l2_intf_gid)
|
| #add vlan flow table
|
| add_one_vlan_table_flow(self.controller, port, vlan_id, flag=VLAN_TABLE_FLAG_ONLY_BOTH)
|
|
|
| #add termination flow
|
| add_termination_flow(self.controller, port1, 0x0800, [0x01, 0x00, 0x5e, 0x00, 0x00, 0x00], vlan_id)
|
|
|
| #add l3 interface group
|
| mcat_group_msg=add_l3_mcast_group(self.controller, vlan_id, 2, l2_intf_group_list)
|
| add_mcast4_routing_flow(self.controller, vlan_id, src_ip, 0, dst_ip, mcat_group_msg.group_id)
|
|
|
| parsed_pkt = simple_udp_packet(pktlen=100,
|
| 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)
|
| verify_packet(self, pkt, port2)
|
| verify_no_other_packets(self)
|
|
|
|
|
|
|