def lossy_configs(testbed, conn_graph_facts, duthost, lossless_prio_dscp_map, one_hundred_gbe, start_delay, serializer): for config in one_hundred_gbe: bg_dscp_list = [prio for prio in lossless_prio_dscp_map] test_dscp_list = [x for x in range(64) if x not in bg_dscp_list] vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] tx_port_ip = vlan_ip_addrs[1] rx_port_ip = vlan_ip_addrs[0] tx_gateway_ip = gw_addr rx_gateway_ip = gw_addr test_flow_name = 'Test Data' background_flow_name = 'Background Data' test_line_rate = 50 background_line_rate = 50 pause_line_rate = 100 configure_pause_frame = 1 ###################################################################### # Create TX stack configuration ###################################################################### tx_ipv4 = Ipv4(name='Tx Ipv4', address=Pattern(tx_port_ip), prefix=Pattern('24'), gateway=Pattern(tx_gateway_ip)) tx_ethernet = Ethernet(name='Tx Ethernet', ipv4=tx_ipv4) tx_device = Device(name='Tx Device', devices_per_port=1, ethernets=[tx_ethernet]) tx_device_group = DeviceGroup(name='Tx Device Group', port_names=['Tx'], devices=[tx_device]) config.device_groups.append(tx_device_group) ###################################################################### # Create RX stack configuration ###################################################################### rx_ipv4 = Ipv4(name='Rx Ipv4', address=Pattern(rx_port_ip), prefix=Pattern('24'), gateway=Pattern(rx_gateway_ip)) rx_ethernet = Ethernet(name='Rx Ethernet', ipv4=rx_ipv4) rx_device = Device(name='Rx Device', devices_per_port=1, ethernets=[rx_ethernet]) rx_device_group = DeviceGroup(name='Rx Device Group', port_names=['Rx'], devices=[rx_device]) config.device_groups.append(rx_device_group) ###################################################################### # Traffic configuration Test data ###################################################################### data_endpoint = DeviceEndpoint(tx_device_names=[tx_device.name], rx_device_names=[rx_device.name], packet_encap='ipv4', src_dst_mesh='', route_host_mesh='', bi_directional=False, allow_self_destined=False) test_dscp = Priority(Dscp(phb=FieldPattern(choice=test_dscp_list))) test_flow = Flow(name=test_flow_name, endpoint=Endpoint(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=test_dscp)) ], size=Size(1024), rate=Rate('line', test_line_rate), duration=Duration( Fixed(packets=0, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(test_flow) ####################################################################### # Traffic configuration Background data ####################################################################### background_dscp = Priority(Dscp(phb=FieldPattern(choice=bg_dscp_list))) background_flow = Flow( name=background_flow_name, endpoint=Endpoint(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=background_dscp)) ], size=Size(1024), rate=Rate('line', background_line_rate), duration=Duration( Fixed(packets=0, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(background_flow) ####################################################################### # Traffic configuration Pause ####################################################################### if (configure_pause_frame): pause_endpoint = PortEndpoint(tx_port_name='Rx', rx_port_names=['Rx']) pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='E7'), pause_class_0=FieldPattern(choice='ffff'), pause_class_1=FieldPattern(choice='ffff'), pause_class_2=FieldPattern(choice='ffff'), pause_class_3=FieldPattern(choice='0'), pause_class_4=FieldPattern(choice='0'), pause_class_5=FieldPattern(choice='ffff'), pause_class_6=FieldPattern(choice='ffff'), pause_class_7=FieldPattern(choice='ffff'), )) pause_flow = Flow(name='Pause Storm', endpoint=Endpoint(pause_endpoint), packet=[pause], size=Size(64), rate=Rate('line', value=pause_line_rate), duration=Duration( Fixed(packets=0, delay=0, delay_unit='nanoseconds'))) config.flows.append(pause_flow) return one_hundred_gbe
def base_configs(testbed, conn_graph_facts, duthost, lossless_prio_dscp_map, one_hundred_gbe, start_delay, traffic_duration, pause_line_rate, traffic_line_rate, pause_frame_type, frame_size, serializer): for config in one_hundred_gbe: start_delay = start_delay * 1000000000.0 bg_dscp_list = [str(prio) for prio in lossless_prio_dscp_map] test_dscp_list = [str(x) for x in range(64) if x not in bg_dscp_list] tx = config.ports[0] rx = config.ports[1] vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] tx_port_ip = vlan_ip_addrs[1] rx_port_ip = vlan_ip_addrs[0] tx_gateway_ip = gw_addr rx_gateway_ip = gw_addr test_flow_name = 'Test Data' background_flow_name = 'Background Data' test_line_rate = traffic_line_rate background_line_rate = traffic_line_rate pause_line_rate = pause_line_rate pytest_assert( test_line_rate + background_line_rate <= 100, "test_line_rate + background_line_rate should be less than 100") ###################################################################### # Create TX stack configuration ###################################################################### tx_ipv4 = Ipv4(name='Tx Ipv4', address=Pattern(tx_port_ip), prefix=Pattern('24'), gateway=Pattern(tx_gateway_ip), ethernet=Ethernet(name='Tx Ethernet')) tx.devices.append( Device(name='Tx Device', device_count=1, choice=tx_ipv4)) ###################################################################### # Create RX stack configuration ###################################################################### rx_ipv4 = Ipv4(name='Rx Ipv4', address=Pattern(rx_port_ip), prefix=Pattern('24'), gateway=Pattern(rx_gateway_ip), ethernet=Ethernet(name='Rx Ethernet')) rx.devices.append( Device(name='Rx Device', device_count=1, choice=rx_ipv4)) ###################################################################### # Traffic configuration Test data ###################################################################### data_endpoint = DeviceTxRx( tx_device_names=[tx.devices[0].name], rx_device_names=[rx.devices[0].name], ) test_dscp = Priority(Dscp(phb=FieldPattern(choice=test_dscp_list))) test_flow = Flow(name=test_flow_name, tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=test_dscp)) ], size=Size(frame_size), rate=Rate('line', test_line_rate), duration=Duration( FixedSeconds(seconds=traffic_duration, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(test_flow) ####################################################################### # Traffic configuration Background data ####################################################################### background_dscp = Priority(Dscp(phb=FieldPattern(choice=bg_dscp_list))) background_flow = Flow( name=background_flow_name, tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=background_dscp)) ], size=Size(frame_size), rate=Rate('line', background_line_rate), duration=Duration( FixedSeconds(seconds=traffic_duration, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(background_flow) ####################################################################### # Traffic configuration Pause ####################################################################### pause_endpoint = PortTxRx(tx_port_name='Rx', rx_port_names=['Rx']) if (pause_frame_type == 'priority'): pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='E7'), pause_class_0=FieldPattern(choice='ffff'), pause_class_1=FieldPattern(choice='ffff'), pause_class_2=FieldPattern(choice='ffff'), pause_class_3=FieldPattern(choice='0'), pause_class_4=FieldPattern(choice='0'), pause_class_5=FieldPattern(choice='ffff'), pause_class_6=FieldPattern(choice='ffff'), pause_class_7=FieldPattern(choice='ffff'), )) pause_flow = Flow(name='Pause Storm', tx_rx=TxRx(pause_endpoint), packet=[pause], size=Size(64), rate=Rate('line', value=100), duration=Duration( FixedPackets(packets=0, delay=0, delay_unit='nanoseconds'))) elif (pause_frame_type == 'global'): pause = Header( EthernetPause(dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'))) pause_flow = Flow(name='Pause Storm', tx_rx=TxRx(pause_endpoint), packet=[pause], size=Size(64), rate=Rate('line', value=pause_line_rate), duration=Duration( FixedPackets(packets=0, delay=0, delay_unit='nanoseconds'))) else: pass config.flows.append(pause_flow) return one_hundred_gbe
def testbed_config(conn_graph_facts, fanout_graph_facts, duthost): ixia_fanout = get_peer_ixia_chassis(conn_data=conn_graph_facts, dut_hostname=duthost.hostname) pytest_require(ixia_fanout is not None, skip_message="Cannot find the peer IXIA chassis") ixia_fanout_id = list(fanout_graph_facts.keys()).index(ixia_fanout) ixia_fanout_list = IxiaFanoutManager(fanout_graph_facts) ixia_fanout_list.get_fanout_device_details(device_number=ixia_fanout_id) ixia_ports = ixia_fanout_list.get_ports(peer_device=duthost.hostname) pytest_require(len(ixia_ports) >= 2, skip_message="The test requires at least two ports") rx_id = 0 tx_id = 1 rx_port_location = get_tgen_location(ixia_ports[rx_id]) tx_port_location = get_tgen_location(ixia_ports[tx_id]) rx_port_speed = int(ixia_ports[rx_id]['speed']) tx_port_speed = int(ixia_ports[tx_id]['speed']) pytest_require(rx_port_speed == tx_port_speed, skip_message="Two ports should have the same speed") """ L1 configuration """ rx_port = Port(name='Rx Port', location=rx_port_location) tx_port = Port(name='Tx Port', location=tx_port_location) pfc = Ieee8021qbb(pfc_delay=1, pfc_class_0=0, pfc_class_1=1, pfc_class_2=2, pfc_class_3=3, pfc_class_4=4, pfc_class_5=5, pfc_class_6=6, pfc_class_7=7) flow_ctl = FlowControl(choice=pfc) auto_negotiation = AutoNegotiation(link_training=True, rs_fec=True) l1_config = Layer1(name='L1 config', speed='speed_%d_gbps' % (rx_port_speed / 1000), auto_negotiate=False, auto_negotiation=auto_negotiation, flow_control=flow_ctl, port_names=[tx_port.name, rx_port.name]) config = Config(ports=[tx_port, rx_port], layer1=[l1_config], options=Options(PortOptions(location_preemption=True))) vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) gw_addr = vlan_subnet.split('/')[0] prefix = vlan_subnet.split('/')[1] tx_port_ip = vlan_ip_addrs[0] rx_port_ip = vlan_ip_addrs[1] tx_gateway_ip = gw_addr rx_gateway_ip = gw_addr """ L2/L3 configuration """ tx_ipv4 = Ipv4(name='Tx Ipv4', address=Pattern(tx_port_ip), prefix=Pattern(prefix), gateway=Pattern(tx_gateway_ip), ethernet=Ethernet(name='Tx Ethernet')) config.devices.append( Device(name='Tx Device', device_count=1, container_name=tx_port.name, choice=tx_ipv4)) rx_ipv4 = Ipv4(name='Rx Ipv4', address=Pattern(rx_port_ip), prefix=Pattern(prefix), gateway=Pattern(rx_gateway_ip), ethernet=Ethernet(name='Rx Ethernet')) config.devices.append( Device(name='Rx Device', device_count=1, container_name=rx_port.name, choice=rx_ipv4)) return config
def ixia_testbed(conn_graph_facts, fanout_graph_facts, duthosts, rand_one_dut_hostname): """ L2/L3 Tgen API config for the T0 testbed Args: conn_graph_facts (pytest fixture) fanout_graph_facts (pytest fixture) duthosts (pytest fixture): list of DUTs rand_one_dut_hostname (pytest fixture): DUT hostname Returns: L2/L3 config for the T0 testbed """ duthost = duthosts[rand_one_dut_hostname] ixia_fanout = get_peer_ixia_chassis(conn_data=conn_graph_facts, dut_hostname=duthost.hostname) if ixia_fanout is None: return None ixia_fanout_id = list(fanout_graph_facts.keys()).index(ixia_fanout) ixia_fanout_list = IxiaFanoutManager(fanout_graph_facts) ixia_fanout_list.get_fanout_device_details(device_number=ixia_fanout_id) ixia_ports = ixia_fanout_list.get_ports(peer_device=duthost.hostname) ports = list() port_names = list() port_speed = None """ L1 config """ for i in range(len(ixia_ports)): port = Port(name='Port {}'.format(i), location=get_tgen_location(ixia_ports[i])) ports.append(port) port_names.append(port.name) if port_speed is None: port_speed = int(ixia_ports[i]['speed']) elif port_speed != int(ixia_ports[i]['speed']): """ All the ports should have the same bandwidth """ return None pfc = Ieee8021qbb(pfc_delay=0, pfc_class_0=0, pfc_class_1=1, pfc_class_2=2, pfc_class_3=3, pfc_class_4=4, pfc_class_5=5, pfc_class_6=6, pfc_class_7=7) flow_ctl = FlowControl(choice=pfc) auto_negotiation = AutoNegotiation(link_training=True, rs_fec=True) l1_config = Layer1(name='L1 config', speed='speed_%d_gbps' % int(port_speed / 1000), auto_negotiate=False, auto_negotiation=auto_negotiation, ieee_media_defaults=False, flow_control=flow_ctl, port_names=port_names) config = Config(ports=ports, layer1=[l1_config], options=Options(PortOptions(location_preemption=True))) """ L2/L3 config """ vlan_subnet = get_vlan_subnet(duthost) if vlan_subnet is None: return None vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, len(ixia_ports)) gw_addr = vlan_subnet.split('/')[0] prefix = vlan_subnet.split('/')[1] for i in range(len(ixia_ports)): ip_stack = Ipv4(name='Ipv4 {}'.format(i), address=Pattern(vlan_ip_addrs[i]), prefix=Pattern(prefix), gateway=Pattern(gw_addr), ethernet=Ethernet(name='Ethernet {}'.format(i))) device = Device(name='Device {}'.format(i), device_count=1, container_name=port_names[i], choice=ip_stack) config.devices.append(device) return config
def __vlan_intf_config(config, port_config_list, duthost, ixia_ports): """ Generate Tgen configuration of Vlan interfaces Args: config (obj): Tgen API config of the testbed port_config_list (list): list of IXIA port configuration information duthost (object): device under test ixia_ports (list): list of IXIA port information Returns: True if we successfully generate configuration or False """ mg_facts = duthost.minigraph_facts(host=duthost.hostname)['ansible_facts'] vlan_facts = mg_facts['minigraph_vlans'] if len(vlan_facts) == 0: return True vlan_member = {} for k, v in vlan_facts.items(): vlan_member[k] = v['members'] vlan_intf_facts = mg_facts['minigraph_vlan_interfaces'] vlan_intf = {} for v in vlan_intf_facts: if v['prefixlen'] <= 32: vlan_intf[v['attachto']] = v dut_mac = duthost.facts['router_mac'] """ For each Vlan """ for vlan in vlan_member: phy_intfs = vlan_member[vlan] gw_addr = str(vlan_intf[vlan]['addr']) prefix = str(vlan_intf[vlan]['prefixlen']) vlan_subnet = '{}/{}'.format(gw_addr, prefix) vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, len(phy_intfs)) """ For each physical interface attached to this Vlan """ for i in range(len(phy_intfs)): phy_intf = phy_intfs[i] vlan_ip_addr = vlan_ip_addrs[i] port_ids = [id for id, ixia_pot in enumerate(ixia_ports) \ if ixia_pot['peer_port'] == phy_intf] if len(port_ids) != 1: return False port_id = port_ids[0] mac = __gen_mac(port_id) ethernet = Ethernet(name='Ethernet Port {}'.format(port_id), mac=Pattern(mac)) ip_stack = Ipv4(name='Ipv4 Port {}'.format(port_id), address=Pattern(vlan_ip_addr), prefix=Pattern(prefix), gateway=Pattern(gw_addr), ethernet=ethernet) device = Device(name='Device Port {}'.format(port_id), device_count=1, container_name=config.ports[port_id].name, choice=ip_stack) config.devices.append(device) port_config = IxiaPortConfig(id=port_id, ip=vlan_ip_addr, mac=mac, gw=gw_addr, gw_mac=dut_mac, prefix_len=prefix, port_type=IxiaPortType.VlanMember, peer_port=phy_intf) port_config_list.append(port_config) return True
def run_pfc_exp(session, dut, tx_port, rx_port, port_bw, test_prio_list, test_dscp_list, bg_dscp_list, exp_dur, start_delay=START_DELAY, test_traffic_pause_expected=True, send_pause_frame=True): """ Run a PFC experiment. 1. IXIA sends test traffic and background traffic from tx_port. 2. IXIA sends PFC pause frames from rx_port to pause priorities. 3. Background traffic should not be interruped - all background traffic will be received at the rx_port. 4. No test traffic will be received at the rx_port when pause priority is equal to test traffic priority. Note: PFC pause frames should always be dropped, regardless of their pause priorities. Args: session (IxNetwork Session object): IxNetwork session. dut (object): Ansible instance of SONiC device under test (DUT). tx_port (object Ixia vport): IXIA port to transmit traffic. rx_port (object Ixia vport): IXIA port to receive traffic. port_bw (int): bandwidth (in Mbps) of tx_port and rx_port. test_prio_list (list of integers): PFC priorities of test traffic and PFC pause frames. test_dscp_list (list of integers): DSCP values of test traffic. bg_dscp_list (list of integers): DSCP values of background traffic. exp_dur (integer): experiment duration in second. start_delay (float): approximated initial delay to start the traffic. test_traffic_pause_expected (bool): Do you expect test traffic to be stopped? If yes, this should be true; false otherwise. send_pause_frame (bool): True/False depending on whether you want to send pause frame Rx port or not. Returns: This function returns nothing. """ # Disable DUT's PFC watchdog. dut.shell('sudo pfcwd stop') vlan_subnet = get_vlan_subnet(dut) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") gw_addr = vlan_subnet.split('/')[0] # One for sender and the other one for receiver. vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) topo_receiver = create_topology(session=session, name="Receiver", ports=list(rx_port), ip_start=vlan_ip_addrs[0], ip_incr_step='0.0.0.1', gw_start=gw_addr, gw_incr_step='0.0.0.0') # Assumption: Line rate percentage of background data traffic # is equal to Line rate percentage of test data traffic. pytest_assert(2 * RATE_PERCENTAGE <= 100, "Value of RATE_PERCENTAGE should not be more than 50!") topo_sender = create_topology(session=session, name="Sender", ports=list(tx_port), ip_start=vlan_ip_addrs[1], ip_incr_step='0.0.0.1', gw_start=gw_addr, gw_incr_step='0.0.0.0') start_protocols(session) test_traffic = create_ipv4_traffic(session=session, name='Test Data Traffic', source=topo_sender, destination=topo_receiver, pkt_size=DATA_PKT_SIZE, duration=exp_dur, rate_percent=RATE_PERCENTAGE, start_delay=start_delay, dscp_list=test_dscp_list, lossless_prio_list=test_prio_list) bg_priority_list = [b for b in range(8) if b not in test_prio_list] background_traffic = create_ipv4_traffic( session=session, name='Background Data Traffic', source=topo_sender, destination=topo_receiver, pkt_size=DATA_PKT_SIZE, duration=exp_dur, rate_percent=RATE_PERCENTAGE, start_delay=start_delay, dscp_list=bg_dscp_list, lossless_prio_list=bg_priority_list) # Pause time duration (in second) for each PFC pause frame. pause_dur_per_pkt = 65535 * 64 * 8.0 / (port_bw * 1000000) # Do not specify duration here as we want it keep running. if send_pause_frame: pfc_traffic = create_pause_traffic(session=session, name='PFC Pause Storm', source=rx_port, pkt_per_sec=1.1 / pause_dur_per_pkt, start_delay=0, global_pause=False, pause_prio_list=test_prio_list) start_traffic(session) # Wait for test and background traffic to finish. time.sleep(exp_dur + start_delay + 1) # Capture traffic statistics. flow_statistics = get_traffic_statistics(session) logger.info(flow_statistics) exp_tx_bytes = (exp_dur * port_bw * 1000000 * (RATE_PERCENTAGE / 100.0)) / 8 for row_number, flow_stat in enumerate(flow_statistics.Rows): tx_frames = int(flow_stat['Tx Frames']) rx_frames = int(flow_stat['Rx Frames']) rx_bytes = int(flow_stat['Rx Bytes']) tolerance_ratio = rx_bytes / exp_tx_bytes if 'Test' in flow_stat['Traffic Item']: if test_traffic_pause_expected: pytest_assert(tx_frames > 0 and rx_frames == 0, "Test traffic should be fully paused") else: pytest_assert(tx_frames > 0 and tx_frames == rx_frames, "Test traffic packets should not be dropped") if ((tolerance_ratio < TOLERANCE_THRESHOLD) or (tolerance_ratio > 1)): logger.error("Expected Tx/Rx = %s actual Rx = %s" % (exp_tx_bytes, rx_bytes)) logger.error("tolerance_ratio = %s" % (tolerance_ratio)) pytest_assert( False, "expected % of packets not received at the RX port") elif 'PFC' in flow_stat['Traffic Item']: pytest_assert(tx_frames > 0 and rx_frames == 0, "PFC packets should be dropped") else: pytest_assert(tx_frames > 0 and tx_frames == rx_frames, "Background traffic should not be impacted") if ((tolerance_ratio < TOLERANCE_THRESHOLD) or (tolerance_ratio > 1)): logger.error("Expected Tx/Rx = %s actual Rx = %s" % (exp_tx_bytes, rx_bytes)) logger.error("tolerance_ratio = %s" % (tolerance_ratio)) pytest_assert( False, "expected % of packets not received at the RX port") stop_traffic(session)
def _pfcwd_configs(prio): """ A fixture to create pfcwd configs on traffic generator using open traffic genertor model :param prio: dscp priority 3 or 4 """ vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 3) gw_addr = vlan_subnet.split('/')[0] device1_ip = vlan_ip_addrs[0] device2_ip = vlan_ip_addrs[1] device3_ip = vlan_ip_addrs[2] device1_gateway_ip = gw_addr device2_gateway_ip = gw_addr device3_gateway_ip = gw_addr available_phy_port = ports_config.get_available_phy_ports() pytest_assert( len(available_phy_port) > 3, "Number of physical ports must be at least 3") ports_list = ports_config.create_ports_list(no_of_ports=3) configs = [] for phy_ports in ports_list: config = ports_config.create_config(phy_ports) line_rate = traffic_line_rate ###################################################################### # Device Configuration ###################################################################### port1 = config.ports[0] port2 = config.ports[1] port3 = config.ports[2] #Device 1 configuration port1.devices = [ Device(name='Port 1', device_count=1, choice=Ipv4(name='Ipv4 1', address=Pattern(device1_ip), prefix=Pattern('24'), gateway=Pattern(device1_gateway_ip), ethernet=Ethernet(name='Ethernet 1'))) ] #Device 2 configuration port2.devices = [ Device(name='Port 2', device_count=1, choice=Ipv4(name='Ipv4 2', address=Pattern(device2_ip), prefix=Pattern('24'), gateway=Pattern(device2_gateway_ip), ethernet=Ethernet(name='Ethernet 2'))) ] #Device 3 configuration port3.devices = [ Device(name='Port 3', device_count=1, choice=Ipv4(name='Ipv4 3', address=Pattern(device3_ip), prefix=Pattern('24'), gateway=Pattern(device3_gateway_ip), ethernet=Ethernet(name='Ethernet 3'))) ] device1 = port1.devices[0] device2 = port2.devices[0] device3 = port3.devices[0] ###################################################################### # Traffic configuration Traffic 1->2 ###################################################################### dscp_prio = Priority(Dscp(phb=FieldPattern(choice=[str(prio)]))) flow_1to2 = Flow(name="Traffic 1->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device1.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_prio)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_1to2) ###################################################################### # Traffic configuration Traffic 2->1 ###################################################################### flow_2to1 = Flow(name="Traffic 2->1", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device1.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_prio)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to1) ###################################################################### # Traffic configuration Traffic 2->3 ####################################################################### flow_2to3 = Flow(name="Traffic 2->3", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device3.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_prio)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to3) ###################################################################### # Traffic configuration Traffic 3->2 ####################################################################### flow_3to2 = Flow(name="Traffic 3->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device3.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_prio)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_3to2) ####################################################################### # Traffic configuration Pause ####################################################################### if prio == 3: pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='8'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='ffff'), pause_class_4=FieldPattern(choice='0'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) elif prio == 4: pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='10'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='0'), pause_class_4=FieldPattern(choice='ffff'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) else: pytest_assert( False, "This testcase supports only lossless priorities 3 & 4, need to enhance the script based on requirement" ) pause_flow = Flow(name='Pause Storm', tx_rx=TxRx( PortTxRx(tx_port_name=port3.name, rx_port_names=[port3.name])), packet=[pause], size=Size(64), rate=Rate('line', value=pause_line_rate), duration=Duration( Continuous(delay=t_start_pause * (10**9), delay_unit='nanoseconds'))) config.flows.append(pause_flow) configs.append(config) return configs
def _pfc_watch_dog_config(pi): vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 3) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] device1_ip = vlan_ip_addrs[0] device2_ip = vlan_ip_addrs[1] device3_ip = vlan_ip_addrs[2] device1_gateway_ip = gw_addr device2_gateway_ip = gw_addr device3_gateway_ip = gw_addr config = one_hundred_gbe.create_config() line_rate = pfcwd_params['traffic_line_rate'] pause_line_rate = pfcwd_params['pause_line_rate'] start_delay = pfcwd_params['start_delay'] frame_size = pfcwd_params['frame_size'] t_start_pause = pfcwd_params['t_start_pause'] ###################################################################### # Device Configuration ###################################################################### port1 = config.ports[0] port2 = config.ports[1] port3 = config.ports[2] #Device 1 configuration port1.devices = [ Device(name='Port 1', device_count=1, choice=Ipv4(name='Ipv4 1', address=Pattern(device1_ip), prefix=Pattern('24'), gateway=Pattern(device1_gateway_ip), ethernet=Ethernet(name='Ethernet 1'))) ] #Device 2 configuration port2.devices = [ Device(name='Port 2', device_count=1, choice=Ipv4(name='Ipv4 2', address=Pattern(device2_ip), prefix=Pattern('24'), gateway=Pattern(device2_gateway_ip), ethernet=Ethernet(name='Ethernet 2'))) ] #Device 3 configuration port3.devices = [ Device(name='Port 3', device_count=1, choice=Ipv4(name='Ipv4 3', address=Pattern(device3_ip), prefix=Pattern('24'), gateway=Pattern(device3_gateway_ip), ethernet=Ethernet(name='Ethernet 3'))) ] device1 = port1.devices[0] device2 = port2.devices[0] device3 = port3.devices[0] ###################################################################### # Traffic configuration Traffic 1->2 ###################################################################### dscp_pi = Priority(Dscp(phb=FieldPattern(choice=[str(pi)]))) flow_1to2 = Flow(name="Traffic 1->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device1.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_1to2) ###################################################################### # Traffic configuration Traffic 2->1 ###################################################################### flow_2to1 = Flow(name="Traffic 2->1", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device1.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to1) ###################################################################### # Traffic configuration Traffic 2->3 ####################################################################### flow_2to3 = Flow(name="Traffic 2->3", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device2.name], rx_device_names=[device3.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_2to3) ###################################################################### # Traffic configuration Traffic 3->2 ####################################################################### flow_3to2 = Flow(name="Traffic 3->2", tx_rx=TxRx( DeviceTxRx(tx_device_names=[device3.name], rx_device_names=[device2.name])), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=dscp_pi)), ], size=Size(frame_size), rate=Rate('line', line_rate), duration=Duration( Continuous(delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(flow_3to2) ####################################################################### # Traffic configuration Pause ####################################################################### if (pi == 3): pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='8'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='ffff'), pause_class_4=FieldPattern(choice='0'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) elif (pi == 4): pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='10'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='0'), pause_class_4=FieldPattern(choice='ffff'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) else: pytest_assert( False, "This testcase supports only lossless priorities 3 & 4") pause_flow = Flow(name='Pause Storm', tx_rx=TxRx( PortTxRx(tx_port_name=port3.name, rx_port_names=[port3.name])), packet=[pause], size=Size(64), rate=Rate('line', value=pause_line_rate), duration=Duration( Continuous(delay=t_start_pause * (10**9), delay_unit='nanoseconds'))) config.flows.append(pause_flow) return config
def test_testbed(conn_graph_facts, duthosts, rand_one_dut_hostname, fanout_graph_facts, ixia_api_server_session, fanouthosts): duthost = duthosts[rand_one_dut_hostname] logger.info("Connection Graph Facts = %s " % (conn_graph_facts)) logger.info("Fanout Graph facts = %s" % (fanout_graph_facts)) logger.info("DUT hostname = %s" % (duthost.hostname)) ixia_fanout = get_peer_ixia_chassis(conn_data=conn_graph_facts, dut_hostname=duthost.hostname) pytest_require(ixia_fanout is not None, skip_message="Cannot find the peer IXIA chassis") ixia_fanout_id = list(fanout_graph_facts.keys()).index(ixia_fanout) ixia_fanout_list = IxiaFanoutManager(fanout_graph_facts) ixia_fanout_list.get_fanout_device_details(device_number=ixia_fanout_id) logger.info("Configuring ports.") port_list = ixia_fanout_list.get_ports(peer_device=duthost.hostname) session = ixia_api_server_session vports = configure_ports(session=session, port_list=port_list) subnet = get_vlan_subnet(duthost) gw = subnet.split('/')[0] ip_list = get_addrs_in_subnet(subnet=subnet, number_of_ip=len(vports)) logger.info("Creating topology.") topo_receiver = create_topology(session=session, name="Receiver", port_list=[vports[0]], ip_list=[ip_list[0]], gw_list=[gw]) topo_sender = create_topology(session=session, name="Sender", port_list=vports[1:], ip_list=ip_list[1:], gw_list=[gw] * len(vports[1:])) logger.info("Starting all protocols") start_protocols(session) # Create a traffic item logger.info("Configuring traffic.") traffic_item = create_ipv4_traffic(session=session, name="Test Data Traffic", source=topo_sender, destination=topo_receiver) # Generate, apply and start traffic. start_traffic(session) logger.info("run traffic for 5 seconds") time.sleep(5) # Fetch per-flow statistics. stats = dump_flow_statistics(session=session) logger.info(stats) stop_traffic(session) stop_protocols(session)
def base_configs(testbed, conn_graph_facts, duthost, lossless_prio_dscp_map, one_hundred_gbe, start_delay, pause_line_rate, traffic_line_rate, frame_size, ecn_thresholds, serializer): for config in one_hundred_gbe: start_delay = start_delay * 1000000000.0 test_dscp_list = [str(prio) for prio in lossless_prio_dscp_map] tx = config.ports[0] rx = config.ports[1] vlan_subnet = get_vlan_subnet(duthost) pytest_assert(vlan_subnet is not None, "Fail to get Vlan subnet information") vlan_ip_addrs = get_addrs_in_subnet(vlan_subnet, 2) gw_addr = vlan_subnet.split('/')[0] interface_ip_addr = vlan_ip_addrs[0] tx_port_ip = vlan_ip_addrs[1] rx_port_ip = vlan_ip_addrs[0] tx_gateway_ip = gw_addr rx_gateway_ip = gw_addr test_flow_name = 'Test Data' test_line_rate = traffic_line_rate pause_line_rate = pause_line_rate pytest_assert(test_line_rate <= pause_line_rate, "test_line_rate + should be less than pause_line_rate") ###################################################################### # Create TX stack configuration ###################################################################### tx_ipv4 = Ipv4(name='Tx Ipv4', address=Pattern(tx_port_ip), prefix=Pattern('24'), gateway=Pattern(tx_gateway_ip), ethernet=Ethernet(name='Tx Ethernet')) tx.devices.append( Device(name='Tx Device', device_count=1, choice=tx_ipv4)) ###################################################################### # Create RX stack configuration ###################################################################### rx_ipv4 = Ipv4(name='Rx Ipv4', address=Pattern(rx_port_ip), prefix=Pattern('24'), gateway=Pattern(rx_gateway_ip), ethernet=Ethernet(name='Rx Ethernet')) rx.devices.append( Device(name='Rx Device', device_count=1, choice=rx_ipv4)) ###################################################################### # Traffic configuration Test data ###################################################################### data_endpoint = DeviceTxRx( tx_device_names=[tx.devices[0].name], rx_device_names=[rx.devices[0].name], ) pytest_assert(ecn_thresholds < 1024 * 1024, "keep the ECN thresholds less than 1MB") test_dscp = Priority( Dscp(phb=FieldPattern(choice=test_dscp_list), ecn=FieldPattern(Dscp.ECN_CAPABLE_TRANSPORT_1))) # ecn_thresholds in bytes number_of_packets = int(2 * (ecn_thresholds / frame_size)) logger.info("Total number of packets to send = 2 * %s = %s"\ %(ecn_thresholds / frame_size, number_of_packets)) test_flow = Flow(name=test_flow_name, tx_rx=TxRx(data_endpoint), packet=[ Header(choice=EthernetHeader()), Header(choice=Ipv4Header(priority=test_dscp)) ], size=Size(frame_size), rate=Rate('line', test_line_rate), duration=Duration( FixedPackets(packets=number_of_packets, delay=start_delay, delay_unit='nanoseconds'))) config.flows.append(test_flow) ####################################################################### # Traffic configuration Pause ####################################################################### pause_endpoint = PortTxRx(tx_port_name='Rx', rx_port_names=['Rx']) pause = Header( PfcPause( dst=FieldPattern(choice='01:80:C2:00:00:01'), src=FieldPattern(choice='00:00:fa:ce:fa:ce'), class_enable_vector=FieldPattern(choice='18'), pause_class_0=FieldPattern(choice='0'), pause_class_1=FieldPattern(choice='0'), pause_class_2=FieldPattern(choice='0'), pause_class_3=FieldPattern(choice='ffff'), pause_class_4=FieldPattern(choice='ffff'), pause_class_5=FieldPattern(choice='0'), pause_class_6=FieldPattern(choice='0'), pause_class_7=FieldPattern(choice='0'), )) pause_flow = Flow(name='Pause Storm', tx_rx=TxRx(pause_endpoint), packet=[pause], size=Size(64), rate=Rate('line', value=100), duration=Duration( FixedPackets(packets=0, delay=0, delay_unit='nanoseconds'))) config.flows.append(pause_flow) return one_hundred_gbe