def test_acl_statistics(self, env): """ @brief Simple ACL test for ACL Statistics @steps -# Configure ACL: drop all packets. -# Configure ACL: allow packets with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:03:03:03. -# Send streams. -# Get ACL Statistics. -# Verify Statistics has been updated with correct values. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 4], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Configure ACL: drop all packets; # allow only packets with Ethernet.dst=00:00:00:01:01:01 self.suite_logger.debug("Create ACLs") # Configure ACL Expression in format (id, expression, mask, value) expressions = [(1, 'SrcMac', '00:00:00:00:00:00', '00:00:00:00:00:00'), (2, 'DstMac', 'FF:FF:FF:FF:FF:FF', '00:00:00:01:01:01')] # Configure ACL Action in format (id, action, params) # Additional 'Count' action should be added in order to update ACL Statistics actions = [(1, 'Drop', ''), (1, 'Count', ''), (2, 'Allow', ''), (2, 'Count', '')] # Configure ACL Rule in format # (id, expression_id, action_id, stage, enabled, priority) rules = [(1, 1, 1, 'Ingress', 'Enabled', 0), (2, 2, 2, 'Ingress', 'Enabled', 0)] # Create ACLs on device's ports try: env.switch[1].ui.create_acl(ports=device_ports, expressions=expressions, actions=actions, rules=rules) except Exception as err: # Exception in configuration self.suite_logger.debug('ACL configuration failed: %s' % err) pytest.fail('ACL configuration failed') # Wait some time for proper switch behavior time.sleep(1) # Generate test traffic packet_1 = ({ "Ethernet": { "dst": "00:00:00:01:01:01", "src": "00:00:00:02:02:02" } }, { "IP": {} }, { "TCP": {} }) packet_2 = ({ "Ethernet": { "dst": "00:00:00:03:03:03", "src": "00:00:00:04:04:04" } }, { "IP": {} }, { "TCP": {} }) # Send packets to the first port count_2 = 5 count_1 = 10 packet_size = 100 stream_1 = env.tg[1].set_stream(packet_1, count=count_2, iface=sniff_ports[0], required_size=packet_size) stream_2 = env.tg[1].set_stream(packet_2, count=count_1, iface=sniff_ports[0], required_size=packet_size) streams = [stream_1, stream_2] self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].start_streams(streams) # Stop capture env.tg[1].stop_sniff(sniff_ports) # Stop traffic env.tg[1].stop_streams() self.suite_logger.debug("Verify ACl Statistics is updated " "according to the created ACLs") # Get ACL Statistics statistics = env.switch[1].ui.get_table_acl("ACLStatistics") # Get statistics for first ACL Rule stat_1 = [x for x in statistics if x["ruleId"] == 1][0] # Verify statistics assert stat_1["matchPkts"] == count_1 assert stat_1["matchOctets"] == count_1 * packet_size # Get statistics for second ACL Rule stat_1 = [x for x in statistics if x["ruleId"] == 2][0] # Verify statistics assert stat_1["matchPkts"] == count_2 assert stat_1["matchOctets"] == count_2 * packet_size
def test_rxtx_flow_control(self, env): """ @brief Verify that "RxTx" flow control manages traffic correctly. @steps -# Configure FlowControl on switch ports in 'RxTx' mode. -# Send stream of unicast packets with 50% rate to the port 1. -# Send stream of unicast packets with 50% rate to the port 2. -# Send PFC frames to the port 3. -# Verify that line rate on TG port 3 decreases after pause frames with middle quanta are sending @endsteps """ self.suite_logger.info("Define variables for test execution") pause_frame_rate = 30 quanta_value = 4096 # Define active ports ports = env.get_ports([['tg1', 'sw1', 3], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Wait until ports will be in forwarding state. helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][1], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][2], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][3], timeout=120) # Configure two streams of unicast packets. packet_1 = ({"Ethernet": {"dst": "00:00:00:00:00:33", "src": "00:00:00:00:00:11", "type": 0x0800}}, {"IP": {}}) packet_2 = ({"Ethernet": {"dst": "00:00:00:00:00:33", "src": "00:00:00:00:00:22", "type": 0x0800}}, {"IP": {}}) stream_1 = env.tg[1].set_stream(packet_1, iface=ports[('tg1', 'sw1')][1], rate=50, continuous=True) stream_2 = env.tg[1].set_stream(packet_2, iface=ports[('tg1', 'sw1')][2], rate=50, continuous=True) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Configure flow control values for all active ports. env.switch[1].ui.set_flow_control_type([ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2], ports[('sw1', 'tg1')][3]], control_type='RxTx') # Enable Flow Control on TG port 1 and port 2 env.tg[1].set_flow_control(ports[('tg1', 'sw1')][1], True) env.tg[1].set_flow_control(ports[('tg1', 'sw1')][2], True) # Send stream of unicast packets from TG port 1. env.tg[1].start_streams([stream_1, stream_2, ]) time.sleep(3) # Configure stream of pause frames pause_frame = ({"Ethernet": {"dst": "01:80:C2:00:00:01", "src": "00:00:00:00:01:44", "type": 0x8808}}, {"Pause": {"opcode": 0x0001, "ptime": quanta_value}}) stream = env.tg[1].set_stream(pause_frame, iface=ports[('tg1', 'sw1')][3], rate=pause_frame_rate, continuous=True) # Send stream of pause frames from TG port 2. env.tg[1].start_streams([stream, ]) time.sleep(3) self.suite_logger.debug("Start sniffer for detecting pause frames") env.tg[1].start_sniff(sniff_ports, sniffing_time=5, filter_layer='PAUSE') time.sleep(5) # Define transmit rate limits on TG port 1 and port 2 after sending pause frames to "RxTx" flow control port. tx_test_rate1 = env.tg[1].get_port_txrate(ports[('tg1', 'sw1')][1]) tx_test_rate2 = env.tg[1].get_port_txrate(ports[('tg1', 'sw1')][2]) # Define receive rate limit on TG port 3 after sending pause frames to "RxTx" flow control port. rx_test_rate3 = env.tg[1].get_port_rxrate(ports[('tg1', 'sw1')][3]) self.suite_logger.debug("Stop sniffer") data = env.tg[1].stop_sniff(sniff_ports) # Stop streams of unicast packets and pause frames. env.tg[1].stop_streams([stream_1, stream_2, stream, ]) # Verify that pause frames are not forwarded from tested ports. params = ({'layer': "Ethernet", 'field': "src", 'value': "00:00:00:00:01:44"}, ) assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 1 when 'RxTx' is configured on all tested ports." assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 2 when 'RxTx' is configured on all tested ports." assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 3 when 'RxTx' is configured on all tested ports." # Verify that line rate on TG port 3 decreases after pause frames with middle quanta are sending. if self.rate_decreasing(pf_rate=pause_frame_rate, quanta=quanta_value, pause_frame_size=64, full_rate=self.full_rate(sw_instance=env.switch[1], tested_port=ports[('sw1', 'tg1')][3], frame_size=64), actual_rate=rx_test_rate3): self.suite_logger.debug("Line rate decreases properly when stream of pause frames with middle quanta is sent to 'RxTx' port.") else: pytest.fail("Line rate is not decreased properly when stream of pause frames with middle quanta is sent to 'RxTx' port.") # Verify that transmit line rate on TG port 1 is decreased according to configured "RxTx" flow control on all tested ports. if not abs(tx_test_rate1 - (rx_test_rate3 // 2)) <= rx_test_rate3 // 2 * 101 // 100: pytest.fail("Transmit line rate is not decreased accordingly to detected overflow on 'RxTx' egress port.") # Verify that transmit line rate on TG port 2 is decreased according to configured "RxTx" flow control on all tested ports. if not abs(tx_test_rate2 - (rx_test_rate3 // 2)) <= rx_test_rate3 / 2 * 101 // 100: pytest.fail("Transmit line rate is not decreased accordingly to detected overflow on 'RxTx' egress port.")
def test_qinq_vlan_mapping(self, env): """ @brief Verify that customer unmapped packet is received on correct port if provider mapped packet from one Vlan to another is send (Using Vlan Mapping) @steps -# Configure Vlans 200 and 300 on ports 1 and 2. -# Configure port 1 as CustomerMapped. -# Configure port 2 as ProviderMapped. -# Configure Vlan Mapping for port 1, customer vlan 20, provider vlan 200. -# Configure Vlan Mapping for port 1, customer vlan 30, provider vlan 300. -# Send packet with vlan 200 to the port 1. -# Send packet with vlan 300 to the port 1. -# Verify that packets are received on port 2 with correct customer Vlan IDs. @endsteps """ destination_mac = "00:80:C2:04:00:00" source_mac = "00:00:00:00:02:22" destination_mac1 = "00:80:C2:02:00:00" source_mac1 = "00:00:00:00:00:42" vlan_id_customer1 = 20 vlan_id_customer2 = 30 vlan_id_provider1 = 200 vlan_id_provider2 = 300 tp_id_2 = 33024 vlan_priority_customer = 2 vlan_priority_provider = 4 ports = env.get_ports([['tg1', 'sw1', 2], ]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Disable all ports and enable only necessary ones helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) port_id_customer = ports[('sw1', 'tg1')][1] port_id_provider = ports[('sw1', 'tg1')][2] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Generate two vlans env.switch[1].ui.create_vlans(vlans=[vlan_id_provider1, vlan_id_provider2]) # Add second port to provider vlans env.switch[1].ui.create_vlan_ports(ports=[port_id_provider], vlans=[vlan_id_provider1, vlan_id_provider2], tagged='Tagged') # Add customer port to provider vlans env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_provider1, vlan_id_provider2], tagged='Tagged') # Add entries about customer and provider in port table env.switch[1].ui.configure_qinq_ports([port_id_provider], mode='ProviderMapped') env.switch[1].ui.configure_qinq_ports([port_id_provider], tpid=37120) env.switch[1].ui.configure_qinq_ports([port_id_customer], mode='CustomerMapped') env.switch[1].ui.configure_qinq_ports([port_id_customer], tpid=33024) # Set options for vlan mapping env.switch[1].ui.configure_qinq_vlan_mapping([port_id_customer], vlan_id_customer1, vlan_priority_customer, vlan_id_provider1, vlan_priority_provider) env.switch[1].ui.configure_qinq_vlan_mapping([port_id_customer], vlan_id_customer2, vlan_priority_customer, vlan_id_provider2, vlan_priority_provider) # Define packets packet_definition = ({"Ethernet": {"dst": destination_mac, "src": source_mac, "type": 0x9100}}, {"Dot1Q": {"vlan": vlan_id_provider1, "type": 0x0800, "prio": vlan_priority_provider}}, {"IP": {}}) packet_definition1 = ({"Ethernet": {"dst": destination_mac1, "src": source_mac1, "type": 0x9100}}, {"Dot1Q": {"vlan": vlan_id_provider2, "type": 0x0800, "prio": vlan_priority_provider}}, {"IP": {}}) # Wait some time to add all rows to tables time.sleep(1) # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send one packet to the test port. stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][2]) stream_id_1 = env.tg[1].set_stream(packet_definition1, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].start_streams([stream_id, stream_id_1]) data = env.tg[1].stop_sniff(sniff_ports) env.tg[1].stop_streams([stream_id, stream_id_1]) helpers.print_sniffed_data_brief(data) # Verify that customer unmapped packet will be received # in correct port if it is send provider mapped packet assert sniff_ports[0] in list(data.keys()), "No packet on expected port" params = [{"layer": "Ethernet", "field": 'dst', "value": destination_mac.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=tp_id_2), "Type field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_customer1), "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_customer), "Prio field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="type", value=2048), "Type field value isn't equal to expected" params = [{"layer": "Ethernet", "field": 'dst', "value": destination_mac1.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=tp_id_2), "Type field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_customer2), "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_customer), "Prio field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="type", value=2048), "Type field value isn't equal to expected"
def test_acl_traffic(self, env): """ @brief Simple ACL test with traffic @steps -# Configure ACL: drop all packets. -# Configure ACL: allow packets with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:03:03:03. -# Send streams. -# Verify first stream is flooded. -# Verify second stream is discarded. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 4], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Configure ACL: drop all packets; # allow only packets with Ethernet.dst=00:00:00:01:01:01 # Configure ACL Expression in format (id, expression, mask, value) self.suite_logger.debug("Create ACLs") expressions = [(1, 'SrcMac', '00:00:00:00:00:00', '00:00:00:00:00:00'), (2, 'DstMac', 'FF:FF:FF:FF:FF:FF', '00:00:00:01:01:01')] # Configure ACL Action in format (id, action, params) actions = [(1, 'Drop', ''), (2, 'Allow', '')] # Configure ACL Rule in format # (id, expression_id, action_id, stage, enabled, priority) rules = [(1, 1, 1, 'Ingress', 'Enabled', 0), (2, 2, 2, 'Ingress', 'Enabled', 0)] # Create ACLs on device's ports try: env.switch[1].ui.create_acl(ports=device_ports, expressions=expressions, actions=actions, rules=rules) except Exception as err: # Exception in configuration self.suite_logger.debug('ACL configuration failed: %s' % err) pytest.fail('ACL configuration failed') # Wait some time for proper switch behavior time.sleep(1) # Generate test traffic packet_1 = ({ "Ethernet": { "dst": "00:00:00:01:01:01", "src": "00:00:00:02:02:02" } }, { "IP": {} }, { "TCP": {} }) packet_2 = ({ "Ethernet": { "dst": "00:00:00:03:03:03", "src": "00:00:00:04:04:04" } }, { "IP": {} }, { "TCP": {} }) # Send packets to the first port stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=sniff_ports[0]) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=sniff_ports[0]) streams = [stream_1, stream_2] # Start capture self.suite_logger.debug("Start the capture and send the test traffic") env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].start_streams(streams) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Stop traffic env.tg[1].stop_streams() # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data self.suite_logger.debug( "Verify traffic is processed according to the ACLs") # Verify first packet is flooded params_1 = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:00:01:01:01' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02' }] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Verify second packet is dropped params_1 = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:00:03:03:03' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:00:04:04:04' }] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded"
def test_statistics(self, env): """ @brief Work with Statistics """ # Get available TG ports from the environment ports = env.get_ports([ ['tg1', 'sw1', 4], ]) tg_ports = list(ports[('tg1', 'sw1')].values()) # Set necessary ports in Up state helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Create simple streams") # Create packet definition in format # list[dict{LAYER_NAME: dict{LAYER_ATTR: VAL}}] packet_definition = [{ 'Ethernet': { 'src': '00:00:33:33:33:33', 'dst': '00:00:44:44:44:44' } }, { 'IP': { 'src': '20.20.0.12', 'dst': '20.20.0.15' } }] # Configure stream: send 5 packets from link 1 stream = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=5) # 1. Clear Ports statistics env.tg[1].clear_statistics(tg_ports) # Start capture on TG ports for 5 seconds env.tg[1].start_sniff(tg_ports, sniffing_time=5, filter_layer='IP') # Send stream env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames in DEBUG mode helpers.print_sniffed_data_brief(data) # Verify received frames params = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:33:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:44:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 2. Get sent statistics sent_cont = env.tg[1].get_sent_frames_count(tg_ports[0]) assert sent_cont == 5 # 3. Get received frames count (filtered + unfiltered) received_count = env.tg[1].get_received_frames_count(tg_ports[1]) assert received_count >= 5 # 4. Get filtered frames count filtered_count = env.tg[1].get_filtered_frames_count(tg_ports[1]) assert filtered_count == 5
def test_ospf_hello_packets(self, env): """ @brief Verify OSPF hello packet has correct fields after OSPF protocol initialization. @steps -# Add Vlan 100, set pvid on ports 1 to 100 -# Configure OSPF on DUT (area 0.0.0.0) -# Create Route Interface (10.0.1.0 on vlan 100) -# Add Route Interface to the OSPF Area -# Start capture for OSPF Hello packets -# Verify OSPF Hello packets were received @endsteps """ # Define ports. ports = env.get_ports([['tg1', 'sw1', 1], ]) sniff_ports = [ports[('tg1', 'sw1')][1], ] # Disabling all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports, wait_status=True) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Enable Routing. env.switch[1].ui.configure_routing(routing='Enabled', ospf='Enabled') # Configuring general OSPF parameters for four switches. env.switch[1].ui.configure_ospf_router(logAdjacencyChanges='Enabled', routerId='1.1.1.1') # Create test VLAN 100. env.switch[1].ui.create_vlans(vlans=[100]) # Deleting ports from default VLAN. env.switch[1].ui.delete_vlan_ports(ports=[ports[('sw1', 'tg1')][1]], vlans=[1]) # Adding ports to created test VLANs. env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][1], ], vlans=[100], tagged='Tagged') # Set pvid for VLANs ports. env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][1], ], pvid=100) # Configuring general OSPF Area parameters. env.switch[1].ui.create_ospf_area('0.0.0.0') # Adding OSPF route intefaces. env.switch[1].ui.create_route_interface(100, '10.0.1.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_network_2_area(network='10.0.1.1/24', area='0.0.0.0', mode='Disabled') # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=35) # Stop sniffer. data = env.tg[1].stop_sniff(sniff_ports) # Verify Ethernet and IP header of OSPF Hello packet. route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] # Verify source MAC address belongs to route interface. assert sniff_ports[0] in data, 'OSPF Hello packets are not received!' check_pac_fields = False i = 0 packet_time = [] for packet in data[sniff_ports[0]]: # Verify source MAC address belongs to route interface. if env.tg[1].check_packet_field(packet, layer="Ethernet", field="src", value=route_mac.lower()): # Verify destination MAC is 01:00:5E:00:00:05. if env.tg[1].check_packet_field(packet, layer="Ethernet", field="dst", value="01:00:5E:00:00:05"): # Verify correct VLAN Tag. assert env.tg[1].check_packet_field(packet, layer="Dot1Q", field="vlan", value=100) # Verify source IP belongs to Route Interface. assert env.tg[1].check_packet_field(packet, layer="IP", field="src", value="10.0.1.1") # Verify destination IP is 224.0.0.5. assert env.tg[1].check_packet_field(packet, layer="IP", field="dst", value="224.0.0.5") # Verify OSPF header: OSPF version = 2. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hdr", field="version", value=2) # Verify OSPF header: Message type = 1. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hdr", field="type", value=1) # Verify OSPF header: Correct Router ID of the originating router. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hdr", field="src", value="1.1.1.1") # Verify OSPF header: The Area ID of the originating router interface. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hdr", field="area", value="0.0.0.0") # Verify Hello part: The address mask of the originating interface. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="mask", value="255.255.255.0") # Verify Hello part: The HelloInterval of the originating interface. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="hellointerval", value=10) # Verify Hello part: The RouterDeadInterval of the originating interface. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="deadinterval", value=40) # Verify Hello part: The Router Priority. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="prio", value=1) # Verify Hello part: The DR and BDR assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="backup", value="0.0.0.0") assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="router", value="0.0.0.0") # Verify Hello part: Five flag bits signifying optional capabilities. assert env.tg[1].check_packet_field(packet, layer="OSPF_Hello", field="options", value=0x02) packet_time.insert(i, packet.time) i += 1 check_pac_fields = True assert check_pac_fields, "Received OSPF Hello packet is inccorect." # Verify time delay between hello packets is 10 seconds by default. hello_interval = packet_time[2] - packet_time[1] self.suite_logger.debug("Delay between hello packets is {} (should be 10 secconds)".format(hello_interval)) assert int(hello_interval) in range(9, 11), "Delay between hello packets is incorrect"
def test_lacp_frames(self, env): """ @brief Verify that correct LACP frames are transmitted from the configured dynamic LAG @steps -# Add each pair of device ports to separate LAGs -# Wait time until LAG transit to defaulted state -# Sniff for LACP frames on each LAG port -# Verify that device transmits properly formed LACP DUs @endsteps """ slow_protocols_mac = "01:80:c2:00:00:02" ports = env.get_ports([ ['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') dut_mac = env.switch[1].ui.get_table_bridge_info(param="macAddress") sysprio = env.switch[1].ui.get_table_link_aggregation()[0]["priority"] max_delay = env.switch[1].ui.get_table_link_aggregation( )[0]["collectorMaxDelay"] lacp_ethertype = 0x8809 # Configure LAGs lag_config = { ports[("sw1", "tg1")][1]: { 'key': 0, 'portprio': 4096 }, ports[("sw1", "tg1")][2]: { 'key': 0, 'portprio': 4096 }, ports[("sw1", "tg1")][3]: { 'key': 1, 'portprio': 8192 }, ports[("sw1", "tg1")][4]: { 'key': 1, 'portprio': 8192 } } env.switch[1].ui.create_lag(lag=3800, key=0, lag_type='Dynamic', hash_mode='None') env.switch[1].ui.create_lag_ports( ports=[ports[("sw1", "tg1")][1], ports[("sw1", "tg1")][2]], lag=3800, priority=4096, lag_mode='Active', key=0, timeout='Short') env.switch[1].ui.create_lag(lag=3801, key=1, lag_type='Dynamic', hash_mode='None') env.switch[1].ui.create_lag_ports( ports=[ports[("sw1", "tg1")][3], ports[("sw1", "tg1")][4]], lag=3801, priority=8192, lag_mode='Active', key=1, timeout='Short') self.suite_logger.debug("Wait time to transit to defaulted state") time.sleep(5) sniff_tg_ports = list(ports[("tg1", "sw1")].values()) env.tg[1].start_sniff(sniff_tg_ports, sniffing_time=30, dst_filter=slow_protocols_mac) self.suite_logger.debug("Get Actor and Partner operStates.") states = defaultdict(dict) states[ports[("sw1", "tg1")][1]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][1] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][1]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][1] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][2]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][2] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][2]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][2] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][3]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][3] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][3]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][3] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][4]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][4] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][4]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][4] ][0]['partnerOperPortState'] data = env.tg[1].stop_sniff(sniff_tg_ports) helpers.print_sniffed_data_brief(data) self.suite_logger.debug( "Verify that correct LACP frames are sent from each LAG port.") for index in range(1, 5): tg_port = ports[("tg1", "sw1")][index] sw_port = ports[("sw1", "tg1")][index] try: assert data[ tg_port], "No LACP frames sniffed on %s port".format( tg_port) except KeyError: pytest.fail("No LACP frame sniffed on %s port" % tg_port) for lacp_frame in data[tg_port]: prt_state = [ int(bit_val) for bit_val in states[sw_port]["partner"] ] partner_tlv = { "type": 2, "length": 20, "sysprio": 32768, "sys": "00:00:00:00:00:00", "key": 0, "portprio": 32768, "port": 1, "expired": prt_state[0], "defaulted": prt_state[1], "distribute": prt_state[2], "collect": prt_state[3], "synch": prt_state[4], "aggregate": prt_state[5], "timeout": prt_state[6], "activity": prt_state[7], "reserved": "\x00" * 3 } act_state = [ int(bit_val) for bit_val in states[sw_port]["actor"] ] expected_layers = { "Ethernet": { "src": dut_mac, "type": lacp_ethertype }, "LACP": { "version": 1, "subtype": 1 }, "LACPActorInfoTlv": { "type": 1, "length": 20, "sysprio": sysprio, "sys": dut_mac, "key": lag_config[sw_port]['key'], "portprio": lag_config[sw_port]["portprio"], "port": sw_port, "expired": act_state[0], "defaulted": act_state[1], "distribute": act_state[2], "collect": act_state[3], "synch": act_state[4], "aggregate": act_state[5], "timeout": act_state[6], "activity": act_state[7], "reserved": "\x00" * 3 }, "LACPPartnerInfoTlv": partner_tlv, "LACPCollectorInfoTlv": { "type": 3, "length": 16, "maxdelay": max_delay, "reserved": "\x00" * 12 }, "LACPTerminatorTlv": { "type": 0, "length": 0 }, "LACPReserved": { "reserved": "\x00" * 50 } } failures = [] for layer in expected_layers: for field, expected_value in expected_layers[layer].items( ): pack_value = env.tg[1].get_packet_field( lacp_frame, layer, field) try: if isinstance(pack_value, str): assert pack_value.lower() == expected_value.lower(), \ "Incorrect {} field {} value transmitted in LACP frame: {}".format(layer[4:], field, pack_value) else: assert pack_value == expected_value, "Incorrect {} field {} value transmitted in LACP frame: {}".format( layer[4:], field, pack_value) except AssertionError as err: failures.append("%s" % err) if failures: pytest.fail("\n".join(failures))
def test_capture(self, env): """ @brief Capture configuration """ # Get available TG ports from the environment ports = env.get_ports([ ['tg1', 'sw1', 4], ]) tg_ports = list(ports[('tg1', 'sw1')].values()) # Set necessary ports in Up state helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Create simple streams") # Create packet definition in format # list[dict{LAYER_NAME: dict{LAYER_ATTR: VAL}}] packet_definition_1 = [{ 'Ethernet': { 'src': '00:00:00:11:11:11', 'dst': '00:00:00:22:22:22' } }, { 'IP': {} }] packet_definition_2 = [{ 'Ethernet': { 'src': '00:00:00:33:33:33', 'dst': '00:00:00:44:44:44' } }, { 'IP': { 'src': '192.168.0.12', 'dst': '192.168.0.15' } }] # Configure stream: send 5 packets from link 1 stream_1 = env.tg[1].set_stream(packet_definition_1, iface=tg_ports[0], count=5) stream_2 = env.tg[1].set_stream(packet_definition_2, iface=tg_ports[0], count=5) # 1. Start capture on TG ports for 5 seconds env.tg[1].start_sniff(tg_ports, sniffing_time=5) # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture # TAF will wait 'sniffing_time' to stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames in DEBUG mode helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 2. Configure filter by layer: please see list of available # layers in testlib.packet_processor.flt_patterns . # Capture IP frames env.tg[1].start_sniff(tg_ports, sniffing_time=5, filter_layer='IP') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 3. Configure filter by Ethernet.src env.tg[1].start_sniff(tg_ports, sniffing_time=5, src_filter='00:00:00:33:33:33') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 4. Configure filter by Ethernet.dst env.tg[1].start_sniff(tg_ports, sniffing_time=5, dst_filter='00:00:00:44:44:44') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 5. User can combine filter_layer with src and dst filters # Configure filter by Ethernet.dst and IP layer env.tg[1].start_sniff(tg_ports, sniffing_time=5, dst_filter='00:00:00:44:44:44', filter_layer='IP') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 6. Capture certain number of frames # However filtering works after packets were received, # so real number of frames could be less than expected env.tg[1].env.tg[1].start_sniff([tg_ports[1], tg_ports[2]], packets_count=3, filter_layer='IP') env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff([tg_ports[1], tg_ports[2]]) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) <= 3, \ "Packets are not received" # 7. Stop capture immediately env.tg[1].start_sniff(tg_ports, sniffing_time=30) time.sleep(5) env.tg[1].stop_sniff(tg_ports, force=True) # 8. Change captured buffer size (1000 frames by default) env.tg[1].start_sniff(tg_ports, sniffing_time=3) # TAF will return only 5 frames from buffer for each port env.tg[1].stop_sniff(tg_ports, sniff_packet_count=5) # 9. Ignore frames in the captured buffer # use in case test doesn't process captured frames, but # makes decisions based on statistics values env.tg[1].start_sniff(tg_ports, sniffing_time=3) # TAF will return only 5 frames from buffer for each port env.tg[1].stop_sniff(tg_ports, drop_packets=True)
def test_qos_dot1q_strict_mode(self, env): """ @brief Verify that packets with Dot1p higher priority displace packets with Dot1p lower priority by Strict schedule mode @steps -# Set Dot1p trust mode value on ingress port 1 and port 2. -# Set Strict sched mode value on egress port 3. -# Send two streams with different Dot1p priorities. -# Verify that packets with Dot1p higher priority displace packets with Dot1p lower priority @endsteps """ prio_higher = 6 prio_lower = 4 src_1 = "00:00:00:00:01:11" src_2 = "00:00:00:00:02:22" dst_3 = "00:00:00:00:03:33" # Define active ports ports = env.get_ports([ ['sw1', 'tg1', 3], ]) device_ports = list(ports[('sw1', 'tg1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Disable Flow Control functionality env.switch[1].ui.modify_ports(device_ports, flowControl='None') for port in device_ports: env.switch[1].ui.wait_for_port_status(port, 'flowControl', 'None', 10) # Disable Cut Through functionality env.switch[1].ui.modify_ports(device_ports, cutThrough='Disabled') for port in device_ports: env.switch[1].ui.wait_for_port_status(port, 'cutThrough', 'Disabled', 10) # SetUp multicast and broadcast rate limits env.switch[1].ui.modify_ports(device_ports, setPortAttr="mcast_rate", attrVal=0) env.switch[1].ui.modify_ports(device_ports, setPortAttr="bcast_rate", attrVal=0) # Define packets with different Dot1p tags. packet_1 = ({ "Ethernet": { "dst": dst_3, "src": src_1, "type": 0x8100 } }, { "Dot1Q": { "vlan": 1, "type": 0x0800, "prio": prio_higher } }, { "IP": {} }) packet_2 = ({ "Ethernet": { "dst": dst_3, "src": src_2, "type": 0x8100 } }, { "Dot1Q": { "vlan": 1, "type": 0x0800, "prio": prio_lower } }, { "IP": {} }) stream_1 = env.tg[1].set_stream(packet_1, iface=ports[('tg1', 'sw1')][1], rate=100, continuous=True) stream_2 = env.tg[1].set_stream(packet_2, iface=ports[('tg1', 'sw1')][2], rate=100, continuous=True) # Set Dot1p trust mode value on ingress port_1 and port_2. env.switch[1].ui.configure_port_cos( ports=[device_ports[0], device_ports[1]], trustMode="Dot1p") # Verify values have been changed for port in [device_ports[0], device_ports[1]]: port_qos_trust_mode = env.switch[ 1].ui.get_table_ports_qos_scheduling(port=port) assert port_qos_trust_mode['trustMode'] == "Dot1p", \ 'Trust mode value is not set to "Dot1p" for port %s' % port # Set Strict sched mode value on egress port_3. env.switch[1].ui.configure_port_cos(ports=[ device_ports[2], ], schedMode="Strict") # Verify value has been changed port_qos_3_sched_mode = env.switch[ 1].ui.get_table_ports_qos_scheduling(port=device_ports[2]) assert port_qos_3_sched_mode['schedMode'] == "Strict", \ 'Strict sched mode is not set on port %s' % ports[('sw1', 'tg1')][3] # Set Tagged value on egress port_3. env.switch[1].ui.modify_vlan_ports(ports=[ device_ports[2], ], vlans=[ 1, ], tagged="Tagged") # Add Static MAC entry for egress port_3 definition. env.switch[1].ui.create_static_macs(device_ports[2], [ 1, ], [ dst_3, ]) # Set QoS statistic type for Dot1p definition on the TG port_3. env.tg[1].set_qos_stat_type(ports[('tg1', 'sw1')][3], "VLAN") # Need to wait until device generates all ICMP packets. time.sleep(5) # Send streams of packets with Dot1p priorities from the TG port_1 and port_2. env.tg[1].clear_statistics([ ports[('tg1', 'sw1')][1], ports[('tg1', 'sw1')][2], ports[('tg1', 'sw1')][3], ]) env.tg[1].start_sniff([ ports[('tg1', 'sw1')][3], ], filter_layer="Dot1Q.IP", src_filter=src_1, dst_filter=dst_3) env.tg[1].start_streams([ stream_1, stream_2, ]) time.sleep(10) # Stop sending streams from TG port_1 and port_2. env.tg[1].stop_streams([ stream_1, stream_2, ]) time.sleep(0.5) env.tg[1].stop_sniff([ ports[('tg1', 'sw1')][3], ], drop_packets=True) # Get count of sent packets on the TG port_1 and port_2. sent_count_stream_1 = env.tg[1].get_sent_frames_count( ports[('tg1', 'sw1')][1], ) # Get count of received packets with Dot1p higher priority on TG port_3. dot1p_count_stream_1 = env.tg[1].get_qos_frames_count( ports[('tg1', 'sw1')][3], prio_higher) if dot1p_count_stream_1 not in list( range(sent_count_stream_1, sent_count_stream_1 * 101 // 100)): pytest.fail( "Packets with Dot1p higher priority are lost when default mapping is configured." ) # Verify that filtered count of packets on TG port_3 is correct. filtered_count_stream_1 = env.tg[1].get_filtered_frames_count( ports[('tg1', 'sw1')][3], ) if filtered_count_stream_1 != dot1p_count_stream_1: pytest.fail( "Filter packets statistic has incorrect count of packets!") # Verify that not used queues don't receive any packets. if not self.not_used_cos_statistics(tg_instance=env.tg[1], prio_value_1=prio_higher, prio_value_2=prio_lower, iface=ports[('tg1', 'sw1')][3]): pytest.fail("Not used CoS statistics received unexpected packets!")
def test_multicast_traffic(self, env): """ @brief Verify that multicast traffic is forwarded according to the L2Multicast table. @steps -# Create Vlan 2. -# Add ports 1 and 2 into the created Vlan as Tagged. -# Create Multicast record with MAC '01:88:88:88:88:01' in Vlan 1 for port 2. -# Create Multicast record with MAC '01:88:88:88:88:02' in Vlan 2 for port 2. -# Send packet with Ethernet.dst '01:88:88:88:88:01' to the port 1 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:01' to the port 3 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:02' and Vlan 2 to the port 3 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:02' and Vlan 2 to the port 4 -# Verify packet is forwarded to the port 2 @endsteps """ # Set active ports ports = env.get_ports([ ['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Add Vlans: env.switch[1].ui.create_vlans(vlans=[2]) # Add ports to vlans env.switch[1].ui.create_vlan_ports( ports=[ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2]], vlans=[2], tagged='Tagged') # Add multicast records env.switch[1].ui.create_multicast(port=ports[('sw1', 'tg1')][2], vlans=[1], macs=['01:88:88:88:88:01']) env.switch[1].ui.create_multicast(port=ports[('sw1', 'tg1')][2], vlans=[2], macs=['01:88:88:88:88:02']) # Configure multicast streams packet_1 = ({ 'Ethernet': { 'src': '00:11:11:11:11:11', 'dst': '01:88:88:88:88:01' } }, { 'IP': {} }) packet_2 = ({ 'Ethernet': { 'src': '00:11:11:11:11:11', 'dst': '01:88:88:88:88:02', 'type': 0x8100 } }, { 'Dot1Q': { 'vlan': 2 } }, { 'IP': {} }) stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][1]) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=ports[('tg1', 'sw1')][1]) stream_3 = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][3]) stream_4 = env.tg[1].set_stream(packet_2, count=1, iface=ports[('tg1', 'sw1')][4]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Send stream 1 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_1) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_1 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:01' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 2 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_2) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_2 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:02' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 3 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_3) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_3 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:01' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][1], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 1" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 4 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_4) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_4 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:02' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][1], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 1"
def test_dynamic_arp_traffic(self, env): """ @brief Verify that traffic is processed according to the learned Dynamic ARP. @steps -# Perform device preconfiguration. -# Send IP traffic. -# Verify ARP request has been sent. -# Send ARP reply. -# Send IP packets, related to the ARP record, to the first port. -# Verify IP packet is routed. @endsteps """ # Perform device preconfiguration: add vlan and route interface # Get active ports: use two ports for test case ports = env.get_ports([['tg1', 'sw1', 2], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') self.suite_logger.debug("Perform test preconfiguration") env.switch[1].ui.create_vlans(vlans=[10, 20]) env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][1], ], vlans=[10], tagged='Untagged') env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][2], ], vlans=[20], tagged='Untagged') env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][1], ], pvid=10) env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][2], ], pvid=20) env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) env.switch[1].ui.create_route_interface(10, '10.10.10.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_route_interface(20, '20.20.20.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Generate test traffic route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] packet_1 = ({"Ethernet": {"dst": route_mac, "src": "00:00:0a:0a:0a:0a", "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"IP": {"dst": '20.20.20.20', "src": '10.10.10.10'}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][1]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff([ports[('tg1', 'sw1')][2]], sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff([ports[('tg1', 'sw1')][2]]) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify ARP request has been sent") # Get packets from the captured data params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "ARP", "field": 'op', "value": 1}, {"layer": "ARP", "field": 'tpa', "value": '20.20.20.20'}, {"layer": "ARP", "field": 'spa', "value": '20.20.20.1'}] assert len(helpers.get_packet_from_the_port(sniff_port=ports[('tg1', 'sw1')][2], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Send ARP reply arp_reply = ({"Ethernet": {"dst": route_mac, "src": "00:00:14:14:14:14", "type": 0x8100}}, {"Dot1Q": {"vlan": 20}}, {"ARP": {"op": 2, "sha": "00:00:14:14:14:14", "tha": route_mac, "spa": "20.20.20.20", "tpa": "20.20.20.1"}}) arp_stream = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].send_stream(arp_stream) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:14:14:14', ip='20.20.20.20'), 'ARP entry was not added' self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff([ports[('tg1', 'sw1')][2]], sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff([ports[('tg1', 'sw1')][2]]) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the ARP records") # Get packets from the captured data params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:14:14:14:14'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "IP", "field": 'dst', "value": '20.20.20.20'}, {"layer": "IP", "field": 'src', "value": '10.10.10.10'}] assert len(helpers.get_packet_from_the_port(sniff_port=ports[('tg1', 'sw1')][2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_lag_traffic(self, env): """ @brief Verify that port can be added to(removed from) static LAG @steps -# Create static LAG. -# Add two ports into LAG -# Send traffic to the first LAG member. -# Verify traffic is forwarded only from non-LAG members. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) # Disable STP globally in order to avoid traffic loop env.switch[1].ui.configure_spanning_tree(enable="Disabled") helpers.set_ports_admin_enabled(env.switch, active_ports) # Create static LAG entry env.switch[1].ui.create_lag(lag=3800, key=0, lag_type='Static', hash_mode='None') # Add port into the LAG env.switch[1].ui.create_lag_ports(ports=device_ports[:2], lag=3800, key=0) env.switch[1].ui.wait_for_port_value_to_change( ports=[3800] + device_ports[:2], port_parameter='operationalStatus', value='Up') # Generate test traffic packet = ({"Ethernet": {"dst": "00:00:11:11:11:11", "src": "00:00:02:02:02:02"}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data # Verify first packet is sent only to second port params = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:11:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:02:02:02:02'}] #Traffic should be forwarded from non-LAG members assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Traffic should not be forwarded from LAG members assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received"
def test_qinq_vlan_stacking(self, env): """ @brief Verify that packet sent without double-tag from one Vlan to another is received on the correct port with double-tag (Vlan Stacking) @steps -# Configure Vlan 10 on port 1. -# Configure Vlan 100 on ports 1 and 2. -# Configure port 1 as CustomerStacked. -# Configure port 2 as ProviderStacked. -# Configure Vlan Stacking for port 1, provider vlan 100. -# Send packet with vlan 10 to the port 1. -# Verify that packet is double tagged on port 2 @endsteps """ destination_mac = "01:00:5E:00:01:05" source_mac = "00:00:00:00:08:22" vlan_id_customer = 10 vlan_id_provider = 100 vlan_priority_customer = 5 vlan_priority_provider = 6 ports = env.get_ports([['tg1', 'sw1', 2], ]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) port_id_customer = ports[('sw1', 'tg1')][1] port_id_provider = ports[('sw1', 'tg1')][2] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Generate customer and provider vlans env.switch[1].ui.create_vlans(vlans=[vlan_id_customer, vlan_id_provider]) # Add port to customer vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_customer], tagged='Tagged') # Add port to provider vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_provider], vlans=[vlan_id_provider], tagged='Tagged') # Add customer port to provider vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_provider], tagged='Untagged') # Add entries about customer and provider to ports table env.switch[1].ui.configure_qinq_ports([port_id_customer], mode='CustomerStacked') env.switch[1].ui.configure_qinq_ports([port_id_customer], tpid=33024) env.switch[1].ui.configure_qinq_ports([port_id_provider], mode='ProviderStacked') env.switch[1].ui.configure_qinq_ports([port_id_provider], tpid=37120) # Set options for vlan stacking env.switch[1].ui.configure_qinq_vlan_stacking([port_id_customer], vlan_id_provider, vlan_priority_provider) # Define packet without double tag packet_definition = ({"Ethernet": {"dst": destination_mac, "src": source_mac, "type": 0x8100}}, {"Dot1Q": {"vlan": vlan_id_customer, "type": 0x0800, "prio": vlan_priority_customer}}, {"IP": {}}) #Wait some time to add all rows to tables time.sleep(1) # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send one packet to the test port stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that packet is sending without double-tag from one Vlan # to another it will be received in correct port with double-tag assert sniff_ports[1] in list(data.keys()), "No packet on expected port" params = [{"layer": "Ethernet", "field": 'src', "value": source_mac.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=37120), \ "Field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_provider), \ "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_provider), \ "Prio field value isn't equal to expected" layers = env.tg[1].packet_dictionary(packet) dot1q_counter = len([x for x in layers if "Dot1Q" in x]) assert dot1q_counter == 2
def test_sent_pause_frames(self, env): """ @brief Verify that device doesn't flood received pause frames when flow control mode is configured. @steps -# Configure FlowControl on switch ports. -# Send PFC frames to the switch. -# Verify PFC frames are not flooded. @endsteps """ # Define active ports ports = env.get_ports([['tg1', 'sw1', 3], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Wait until ports will be in forwarding state. helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][1], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][2], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][3], timeout=120) # Configure stream of pause frame. pause_frame = ({"Ethernet": {"dst": "01:80:C2:00:00:01", "src": "00:00:00:00:01:44", "type": 0x8808}}, {"Pause": {"opcode": 0x0001, "ptime": 1}}) stream = env.tg[1].set_stream(pause_frame, count=10, iface=ports[('tg1', 'sw1')][1]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Configure flow control values for all active ports. env.switch[1].ui.set_flow_control_type([ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2], ports[('sw1', 'tg1')][3]], control_type='RxTx') # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send pause frame from the TG port 1. env.tg[1].send_stream(stream) data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that Pause Frames are not forwarded from tested ports. params = ({'layer': "Ethernet", 'field': "dst", 'value': "01:80:C2:00:00:01".lower()}, ) assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 1 when PF traffic is sent" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 2 when PF traffic is sent" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 3 when PF traffic is sent"
def test_static_route_one_ports_two_vlans(self, env): """ @brief Verify static route behaviour upon one port with two VLANs. @steps -# Configure Vlans 12 and 34 on port 1. -# Set pvid 12 for port 1. -# Create Route Interface 20.0.12.1/24 on Vlan 12. -# Create Route Interface 20.0.34.1/24 on Vlan 34. -# Create Static Route 10.10.10.0/24 with nexthop 20.0.34.5. -# Verify ARP request 'who has 20.0.34.5' received. -# Send ARP reply. -# Send IP packet with IP.dst 10.10.10.101 to the port 1. -# Verify IP packet is routed to the port 1. @endsteps """ ports = env.get_ports([['tg1', 'sw1', 1], ]) port_1 = ports[('sw1', 'tg1')][1] # Disabling all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch, wait_status=True) helpers.set_ports_admin_enabled(env.switch, ports, wait_status=True) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Define active ports for sniffing. sniff_ports = [ports[('tg1', 'sw1')][1], ] # Enable Routing. env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) # Create test VLAN 10. env.switch[1].ui.create_vlans(vlans=[12, 34]) # Delete port 1 from default VLAN. env.switch[1].ui.delete_vlan_ports(ports=[port_1], vlans=[1]) # Add port 1 to created test VLANs. env.switch[1].ui.create_vlan_ports(ports=[port_1], vlans=[12, 34], tagged='Tagged') # Set proper pvid for port 1 env.switch[1].ui.modify_ports(ports=[port_1], pvid=12) # Add route interfaces. env.switch[1].ui.create_route_interface(12, '20.0.12.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_route_interface(34, '20.0.34.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Add Static route. env.switch[1].ui.create_static_route(ip='10.10.10.0/24', nexthop='20.0.34.5', network='20.0.34.1/24', distance=-1, mode='ip') # Get sniffer data data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify who-has "20.0.34.5" ARP requests received. params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "ARP", "field": 'pdst', "value": '20.0.34.5'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Get routers MAC. route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] # Send ARP reply to port 2. arp_reply = ({"Ethernet": {"src": "00:00:14:00:22:05", "dst": route_mac.lower(), "type": 0x8100}}, {"Dot1Q": {"vlan": 34}}, {"ARP": {"op": 2, "sha": "00:00:14:00:22:05", "tha": route_mac, "tpa": "20.0.34.1", "spa": "20.0.34.5"}}, ) stream_id = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) time.sleep(2) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:00:22:05', ip='20.0.34.5'), 'ARP entry was not added' # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send to switch port 1 untagged IP packet with destination IP 10.10.10.101. packet_definition = ({"Ethernet": {"src": "00:00:20:00:10:65", "dst": route_mac, "type": 0x0800}}, {"IP": {"src": "20.0.12.101", "dst": "10.10.10.101", "p": 17}}, {"UDP": {"dport": 23, "sport": 23}}) stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) # Stop sniffer data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that TG port 1 receive IP packet with destination 10.10.10.101 params_2 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:14:00:22:05'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "IP", "field": 'src', "value": '20.0.12.101'}, {"layer": "IP", "field": 'dst', "value": '10.10.10.101'}, {"layer": "Dot1Q", "field": 'vlan', "value": 34}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_vlan_traffic(self, env): """ @brief Verify that traffic is processed according to the configured Vlan @steps -# Create new Vlan. -# Add two ports into Vlan -# Send traffic to the first Vlan port. -# Verify traffic is forwarded only from second Vlan port. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Create new Vlan env.switch[1].ui.create_vlans(vlans=[ 20, ]) # Add port into the Vlan env.switch[1].ui.create_vlan_ports(ports=device_ports[:2], vlans=[20], tagged='Untagged') # Generate test traffic packet = ({ "Ethernet": { "dst": "00:00:11:11:11:11", "src": "00:00:02:02:02:02", "type": 0x8100 } }, { 'Dot1Q': { 'vlan': 20 } }, { "IP": {} }, { "TCP": {} }) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data # Verify first packet is sent only to second port params = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:11:11:11:11' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:02:02:02:02' }] #Traffic should be forwarded from Vlan ports assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Traffic should not be forwarded from non-Vlan ports assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received"
def test_static_route_two_ports_in_one_vlan(self, env): """ @brief Verify traffic forwarding upon two port on one VLAN and one Router Interface. @steps -# Configure Vlan 10 on ports 1 and 2. -# Create Route Interface 20.0.10.1/24 on Vlan 10. -# Create Static Route 10.10.10.0/24 with nexthop 20.0.10.2. -# Verify ARP request 'who has 20.0.10.2' received on port 2. -# Send ARP reply. -# Send IP packet with IP.dst 10.10.10.101 to the port 1. -# Verify IP packet is routed to the port 2. @endsteps """ # Define active ports. ports = env.get_ports([['tg1', 'sw1', 2], ]) port_1 = ports[('sw1', 'tg1')][1] port_2 = ports[('sw1', 'tg1')][2] # Disabling all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch, wait_status=True) helpers.set_ports_admin_enabled(env.switch, ports, wait_status=True) # Define active ports for sniffing. sniff_ports = [ports[('tg1', 'sw1')][1], ports[('tg1', 'sw1')][2]] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Enable Routing. env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) # Create test VLAN 10. env.switch[1].ui.create_vlans(vlans=[10]) # Add port 1 and port 3 to created test VLAN. env.switch[1].ui.create_vlan_ports(ports=[port_1, port_2], vlans=[10], tagged='Tagged') # Add route interface. env.switch[1].ui.create_route_interface(10, '20.0.10.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Add Static route. env.switch[1].ui.create_static_route(ip='10.10.10.0/24', nexthop='20.0.10.2', network='20.0.10.1/24', distance=-1, mode='ip') # Get sniffer data data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify who-has "20.0.10.2" ARP requests received. params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "ARP", "field": 'tpa', "value": '20.0.10.2'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Get routers MAC. route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] # Send ARP reply to port 2. arp_reply = ({"Ethernet": {"src": "00:00:14:00:0a:02", "dst": route_mac.lower(), "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"ARP": {"op": 2, "sha": "00:00:14:00:0a:02", "tha": route_mac, "tpa": "20.0.10.1", "spa": "20.0.10.2"}}, ) stream_id = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].send_stream(stream_id) time.sleep(2) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:00:0a:02', ip='20.0.10.2'), 'ARP entry was not added' # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send packet with source IP 20.0.10.101 and destination IP 10.10.10.101. packet_definition = ({"Ethernet": {"src": "00:00:10:00:02:65", "dst": route_mac, "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"IP": {"src": "20.0.10.101", "dst": "10.10.10.101", "p": 17}}, {"UDP": {"dport": 23, "sport": 23}}) stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) # Stop sniffer data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify packet with destination 10.10.10.101 is not forwarded back to port 1. params_2 = [{"layer": "IP", "field": 'dst', "value": '10.10.10.101'}, {"layer": "IP", "field": 'src', "value": '20.0.10.101'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_2, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" # Verify packet is received from port 2. assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_stream_configuration(self, env): """ @brief Create simple streams, streams configuration """ # Get available TG ports from the environment ports = env.get_ports([ ['tg1', 'sw1', 4], ]) tg_ports = list(ports[('tg1', 'sw1')].values()) # Set necessary ports in Up state helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Create simple stream") # Create packet definition in format # list[dict{LAYER_NAME: dict{LAYER_ATTR: VAL}}] packet_definition = [{ 'Ethernet': { 'src': '00:00:11:11:11:11', 'dst': '00:00:22:22:22:22' } }, { 'IP': { 'src': '11.11.0.12', 'dst': '12.12.0.15' } }] # 1. Configure stream: send 5 packets from link 1 stream_1 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=5) # Send configured stream env.tg[1].send_stream(stream_1) # 2. Change packet size stream_2 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=5, required_size=120) # Send two stream simultaneously env.tg[1].start_streams([stream_1, stream_2]) time.sleep(2) # Stop streams env.tg[1].stop_streams([stream_1, stream_2]) # 3. Configure continuous traffic stream_3 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], continuous=True) # 4. Configure traffic rate in percent from maximum # Note: rate is supported only on Ixia stream_4 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], continuous=True, rate=50) # 5. Configure interval between frames in seconds stream_5 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], continuous=True, inter=1) # 6. Configure stream with error: set force_errors to none|bad|dribble|align # Note: force_errors is supported only on Ixia stream_6 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=1, force_errors='bad') # 7. Configure increments # for more details see testlib/tg_template.set_stream # Ethernet.src increment: step 2, count 20 stream_7 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], sa_increment=(2, 20), count=20) # IP.src continuous increment with step 2 stream_8 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], sip_increment=(2, 0), continuous=True) # Frame size increment: initial size 70, step 2, max size 78 stream_9 = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=10, required_size=('Increment', 2, 70, 78)) # Start all configured streams streams = [ stream_1, stream_2, stream_3, stream_4, stream_5, stream_6, stream_7, stream_8, stream_9 ] env.tg[1].start_streams(streams) time.sleep(5) # Stop first four streams env.tg[1].stop_streams([stream_1, stream_2, stream_3, stream_4]) time.sleep(5) # Stop all streams env.tg[1].stop_streams()
def test_statistics(self, env): """ @brief Verify that proper Statistics value updated during specific traffic is processed @steps -# Clear all statistics. -# Send 100 unicast frames. -# Verify proper Statistics values. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Generate test traffic packet = ({ "Ethernet": { "dst": "00:00:11:11:11:11", "src": "00:00:02:02:02:02" } }, { "IP": {} }, { "TCP": {} }) # Send packets to the second port stream = env.tg[1].set_stream(packet, count=100, iface=sniff_ports[1]) # Clear all Statistics env.switch[1].ui.clear_statistics() # Get initial Statistics values port_0_tx = env.switch[1].ui.get_table_statistics( port=device_ports[0], stat_name='IfOutUcastPkts') port_1_rx = env.switch[1].ui.get_table_statistics( port=device_ports[1], stat_name='IfInUcastPkts') port_2_tx = env.switch[1].ui.get_table_statistics( port=device_ports[2], stat_name='IfOutUcastPkts') self.suite_logger.debug("Send the test traffic") env.tg[1].send_stream(stream) # Wait for Statistics to be updated time.sleep(15) # Get Statistics port_0_tx_end = env.switch[1].ui.get_table_statistics( port=device_ports[0], stat_name='IfOutUcastPkts') port_1_rx_end = env.switch[1].ui.get_table_statistics( port=device_ports[1], stat_name='IfInUcastPkts') port_2_tx_end = env.switch[1].ui.get_table_statistics( port=device_ports[2], stat_name='IfOutUcastPkts') # Verify Statistics values assert int(port_1_rx_end) - int( port_1_rx) == 100, 'Rx Statistics is wrong' assert int(port_0_tx_end) - int( port_0_tx) == 100, 'Tx Statistics is wrong' assert int(port_2_tx_end) - int( port_2_tx) == 100, 'Tx Statistics is wrong'
def test_routes_table_max_records_count_same_area_traffic_2_ports(self, env): """ @brief Verify that Routes table accommodates at least 1k entries using OSPF routes @steps -# Add Vlans 100 and 200, set pvid on ports 1 and 2 to 100 and 200 -# Configure OSPF on DUT (area 0.0.0.0) -# Create Route Interfaces (10.1.0.0 on vlan 100, 10.2.0.0 on vlan 200) -# Configure OSPF router 2.2.2.2 with 512 routes in route range in IxNetwork on port 1 -# Configure OSPF router 3.3.3.3 with 512 routes in route range in IxNetwork on port 2 -# Start OSPF on IxNetwork -# Wait for DUT's'Route table has 1k records -# Create bidirectional traffic item with src in routes on port 1 and dst in routes from port 2 -# Start traffic on IxNetwork -# Verify traffic loss is not observed @endsteps """ ports = env.get_ports([['tg1', 'sw1', 2], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # =================================== Configure device ===================================================== # Add entry to Vlans Table env.switch[1].ui.create_vlans(vlans=[100, 200]) env.switch[1].ui.delete_vlan_ports(ports=[ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2]], vlans=[1]) env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][1], ], vlans=[100], tagged='Untagged') env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][2], ], vlans=[200], tagged='Untagged') # Setting Primary VLAN ID for ports env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][1], ], pvid=100) env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][2], ], pvid=200) # Configuring general OSPF params env.switch[1].ui.configure_routing(routing='Enabled', ospf='Enabled') env.switch[1].ui.configure_ospf_router(logAdjacencyChanges='Enabled', routerId='1.1.1.1') # Adding default OSPF area env.switch[1].ui.create_ospf_area('0.0.0.0') # Adding OSPF route intefaces env.switch[1].ui.create_route_interface(100, '10.1.0.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_route_interface(200, '10.2.0.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # "OSPF Networks 2 Area" env.switch[1].ui.create_network_2_area(network='10.1.0.1/24', area='0.0.0.0', mode='Disabled') env.switch[1].ui.create_network_2_area(network='10.2.0.1/24', area='0.0.0.0', mode='Disabled') # =================================== Configure IxNetwork ===================================================== tgport1 = ports[('tg1', 'sw1')][1] tgport2 = ports[('tg1', 'sw1')][2] increment_count = 512 session_handle_1 = env.tg[1].OSPF.config(tgport1, reset=True, mode="create", mac_address_init="0000.0a01.0002", intf_ip_addr="10.1.0.2", router_id="2.2.2.2", area_id="0.0.0.0", router_priority=1, neighbor_intf_ip_addr="10.1.0.1", lsa_discard_mode=0, enable_dr_bdr=1, mtu=1500, session_type="ospfv2") env.tg[1].OSPF.topology_route_config(session_handle_1, summary_number_of_prefix=increment_count, summary_prefix_start='192.168.1.1', summary_prefix_length=24, summary_prefix_metric=20, summary_route_type="another_area", type="summary_routes") session_handle_2 = env.tg[1].OSPF.config(tgport2, reset=True, mode="create", mac_address_init="0000.0a02.0002", intf_ip_addr="10.2.0.2", router_id="3.3.3.3", area_id="0.0.0.0", router_priority=1, neighbor_intf_ip_addr="10.2.0.1", lsa_discard_mode=0, enable_dr_bdr=1, mtu=1500, session_type="ospfv2") env.tg[1].OSPF.topology_route_config(session_handle_2, summary_number_of_prefix=increment_count, summary_prefix_start='193.168.1.1', summary_prefix_length=24, summary_prefix_metric=20, summary_route_type="another_area", type="summary_routes") env.tg[1].OSPF.ospf_control(session_handle_1) env.tg[1].OSPF.ospf_control(session_handle_2) # Wait some time for Route table loading self._wait_for_route_table_loading(env.switch[1], 600, 1024) # =================================== Generate traffic ===================================================== env.tg[1].traffic_config(mode='create', transmit_mode='continuous', src_dest_mesh='fully', route_mesh='one_to_one', circuit_type='none', circuit_endpoint_type='ipv4', emulation_src_handle="$%s" % (session_handle_1, ), emulation_dst_handle="$%s" % (session_handle_2, ), rate_percent=99, length_mode='fixed', frame_size=64) env.tg[1].traffic_control(action='run') time.sleep(60) env.tg[1].traffic_control(action='stop') time.sleep(15) env.tg[1].traffic_stats(tgport1) env.tg[1].traffic_stats(tgport2) # Get statistics send_1 = int(env.tg[1].traffic_dictionary[tgport1]['stats']['aggregate']['tx']['total_pkts']) send_2 = int(env.tg[1].traffic_dictionary[tgport2]['stats']['aggregate']['tx']['total_pkts']) receive_1 = int(env.tg[1].traffic_dictionary[tgport1]['stats']['aggregate']['rx']['total_pkts']) receive_2 = int(env.tg[1].traffic_dictionary[tgport2]['stats']['aggregate']['rx']['total_pkts']) assert 0 < receive_2 - send_1 < 40, "Packet loss is observed" assert 0 < receive_1 - send_2 < 40, "Packet loss is observed"
def test_switch_ports_operations(self, env): """ @brief Simple operations with ports. """ # Get active ports. # JSON setup file contain info about links between devices # env.get_ports - returns dictionary of ports in format # {link_key: ports_dict} # where # link_key is a list of device's acronymes # ports_dict contains real port names (IDs) from JSON file # Example: # {('sw1', 'tg1'): {1: 24, 2: 25}, ('tg1', 'sw1'): {1: 'eth1', 2: 'eth2'}} # where switch's port 24 is connected to the traffic generator's port 'eth1', etc. # Get 4 links between switch and tg active_ports = env.get_ports([['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ports: # helpers module contains special methods to operate with ports # Set all switch ports into Admin Down state # in order to omit traffic from other connections helpers.set_all_ports_admin_disabled(env.switch) # Enable only links used in current test case helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Create Static FDB") # Create static Fdb record for second port in configuration mac = "00:00:00:11:11:11" # Get second port of device port_2 = active_ports[('sw1', 'tg1')][2] env.switch[1].ui.create_static_macs(port=port_2, vlans=[1], macs=[mac]) # Generate test traffic packet_1 = ({"Ethernet": {"dst": "00:00:00:11:11:11", "src": "00:00:00:02:02:02"}}, {"IP": {}}, {"TCP": {}}) packet_2 = ({"Ethernet": {"dst": "00:00:00:03:03:03", "src": "00:00:00:04:04:04"}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port # Get first port of TG port_tg_2 = active_ports[('tg1', 'sw1')][1] stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=port_tg_2) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=port_tg_2) streams = [stream_1, stream_2] self.suite_logger.debug("Start the capture and send the test traffic") # Start capture # Configure ports for capture (get all TG ports sniff_ports = list(active_ports[('tg1', 'sw1')].values()) env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].start_streams(streams) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Stop traffic env.tg[1].stop_streams(streams) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the FDB records") # Get packets from the captured data # Verify first packet is sent only to second port params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" # Verify second packet is flooded params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:03:03:03'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:04:04:04'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_mirroring_traffic(self, env): """ @brief Verify that simple Mirroring session can be created and deleted @steps -# Create simple mirroring session. -# Create static Fdb entry -# Send traffic that match created Fdb. -# Verify traffic is forwarded. -# Verify traffic is mirrored. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') self.suite_logger.debug("Create Static FDB") # Create static Fdb record for second port mac = "00:00:00:11:11:11" env.switch[1].ui.create_static_macs(port=device_ports[1], vlans=[1], macs=[mac]) # Create simple mirroring session env.switch[1].ui.create_mirror_session(device_ports[0], device_ports[2], 'IngressAndEgress') # Generate test traffic packet = ({"Ethernet": {"dst": "00:00:00:11:11:11", "src": "00:00:00:02:02:02", "type": 0x8100}}, {"Dot1Q": {"vlan": 1}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the FDB record") # Get packets from the captured data # Verify first packet is sent only to second port params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Verify ingress packet is mirrored params_2 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}, {"layer": "Dot1Q", "field": 'vlan', "value": 1}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_pfc_inhibit_traffic_of_max_sized_frames(self, env, type_of_pfc_config): """ @brief Verify that the DUT inhibits the transmission of max_sized frames when a PFC frame is received with quanta value equal to 1000. @steps -# Connect device with TG -# Configure egress port to accept PFC configurations -# Send DCBX PFC tlv to egress port: pfc enabled for 1 priority -# Configure Dot1p PortsQoS trust mode on ingress ports -# Create Static MAC entry to redirect traffic to egress port -# Transmit priority 1 traffic of max_sized frames from ingress ports -# Transmit pause frames with quanta value 1000 for 1 priority to egress port -# Verify that traffic rate is decreased according to sent pause frames @endsteps """ decrease_rate = 40 ports = env.get_ports([ ['tg1', 'sw1', 3], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) env.switch[1].ui.create_vlans([ 20, ]) env.switch[1].ui.create_vlan_ports( iter(ports[('sw1', 'tg1')].values()), [20], 'Tagged') egress_link = ports[('sw1', 'tg1')][1] egress_tg_port = ports[("tg1", "sw1")][1] ingress_tg_ports = [ports[("tg1", "sw1")][2], ports[("tg1", "sw1")][3]] # Create StaticMac env.switch[1].ui.create_static_macs(ports[('sw1', 'tg1')][1], [ 20, ], [ '00:00:02:02:02:02', ]) if type_of_pfc_config == 'Dcbx': self.configure_dcbx_pfc(env.switch[1], env.tg[1], ports) elif type_of_pfc_config == 'Manual': self.configure_pfc_manually_without_frame_sending( env.switch[1], iter(ports[('sw1', 'tg1')].values()), 1) pause_frame = self.build_pause_frame(src_mac='00:00:02:02:02:02') max_pause_frame_rate = self.get_packets_count_in_traffic_rate( env.tg[1], egress_tg_port, pause_frame, rate=100, size=64) # define priority tagged traffic to transmit through egress port streams = [] tgport_prio_dict = {} iter_ingress_ports = iter(ingress_tg_ports) packet = ({ "Ethernet": { "src": "00:11:11:11:11:12", "dst": '00:00:02:02:02:02' } }, { "Dot1Q": { "prio": 1, "type": 0x0800, "vlan": 20 } }, { "IP": {} }, { "UDP": {} }) for tg_port in iter_ingress_ports: streams.append(env.tg[1].set_stream(packet, iface=tg_port, continuous=True, rate=100, required_size=1518)) tgport_prio_dict[tg_port] = 1 env.tg[1].start_streams(streams) # Wait time to get sustainable traffic rate value time.sleep(2) initial_traffic_rate = env.tg[1].get_port_rxrate(egress_tg_port) env.tg[1].stop_streams() env.tg[1].clear_statistics(ingress_tg_ports + [egress_tg_port]) env.tg[1].set_qos_stat_type(egress_tg_port, "VLAN") self.suite_logger.debug("Start sending Pause frames to egress port") port_speed = env.switch[1].ui.get_table_ports( ports=[ egress_link, ], all_params=True)[0]["speed"] pause_frame_rate = self.get_pause_frames_rate_to_halt_traffic( quanta=1000, port_speed=port_speed, decrease_rate=decrease_rate, max_pause_frame_rate=max_pause_frame_rate) pause_stream = env.tg[1].set_stream(pause_frame, iface=egress_tg_port, continuous=True, rate=pause_frame_rate) env.tg[1].start_sniff([ egress_tg_port, ]) env.tg[1].start_streams([ pause_stream, ] + streams) time.sleep(2) self.suite_logger.debug( "Check port rate after transmitting pause frames") delay_rates = [] end_time = time.time() + 15 while time.time() <= end_time: # Check port rate each 5 seconds after transmitting pause frames actual_traffic_rate = env.tg[1].get_port_rxrate(egress_tg_port) delay_rates.append({ "actual_rate": actual_traffic_rate, "delay_rate": (initial_traffic_rate - actual_traffic_rate) * 100. / initial_traffic_rate }) time.sleep(5) env.tg[1].stop_sniff([ egress_tg_port, ], drop_packets=True) env.tg[1].stop_streams() self.suite_logger.debug( "Verify that traffic rate is decreased according to sent pause frames" ) for rate in delay_rates: assert abs( rate["delay_rate"] - decrease_rate ) <= 3, "Traffic rate is not decreased according to sent pause frames"