def sf_module_prolog():
clear_vlan_configuration(vars.D1)
sf_data.vlan = str(random_vlan_list()[0])
create_vlan(vars.D1, sf_data.vlan)
add_vlan_member(vars.D1,
sf_data.vlan,
port_list=sf_data.port_list,
tagging_mode=True)
sf_data.tg, sf_data.tg_ph_list, sf_data.stream_sf_data = sf_tg_stream_config(
)
def config_rpvst_vlan(dut, mode, vlan_id, new_fwd_delay, new_hello_time, new_max_age, new_priority):
vlan_obj.create_vlan(dut, g_vlan_id)
vlan_obj.add_vlan_member(dut, g_vlan_id, port_list=[g_port1], tagging_mode=True)
stp_obj.config_stp_vlan_param(dut, cfgdictionary={'': [mode, str(vlan_id)]})
stp_obj.config_stp_vlan_param(dut, cfgdictionary={'forward_delay': [str(vlan_id), str(new_fwd_delay)]})
stp_obj.config_stp_vlan_param(dut, cfgdictionary={'hello': [str(vlan_id), str(new_hello_time)]})
stp_obj.config_stp_vlan_param(dut, cfgdictionary={'max_age': [str(vlan_id), str(new_max_age)]})
stp_obj.config_stp_vlan_param(dut, cfgdictionary={'priority': [str(vlan_id), str(new_priority)]})
return True
def copp_fixture_igmp(request, copp_module_hooks):
# copp fixture for igmp
ip_obj.delete_ip_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
vlan_obj.add_vlan_member(vars.D1, vlan_igmp, [vars.D1T1P1])
yield
st.log("### CLEANUP for copp igmp ###")
vlan_obj.delete_vlan_member(vars.D1, vlan_igmp, [vars.D1T1P1], "access")
ip_obj.config_ip_addr_interface(dut=vars.D1,
interface_name=d1_p1,
ip_address='1.1.1.2',
subnet='24')
def test_ft_ipv6_link_local_nh_change():
report_flag = 0
st.log("Clearing all interface counters")
utils.exec_all(True, [[intf_obj.clear_interface_counters, vars.D1], [intf_obj.clear_interface_counters, vars.D2]])
st.log("clearing TG stats")
tgapi.traffic_action_control(tg_handler, actions=['clear_stats'])
st.log("Remove the vlan participation to bring down the Vlan routing intf")
vlan_obj.delete_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True)
vlan_obj.add_vlan_member(vars.D1, data.vlan_li[0], vars.D1D2P2, tagging_mode=True)
if not ip_obj.get_link_local_addresses(vars.D1, data.vlan_in_1):
st.error("ipv6 link local addr is not auto generated after remove and re add of vlan routing intf")
report_flag = 1
pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="del", skip_verify=True)
pc_obj.add_del_portchannel_member(vars.D1, data.prt_chnl, [vars.D1D2P3, vars.D1D2P4], flag="add", skip_verify=True)
if not ip_obj.get_link_local_addresses(vars.D1, data.prt_chnl):
st.error("ipv6 link local addr is not auto generated for {} after remove and re add of members".format(data.prt_chnl))
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = vars.D1D2P1):
st.log("Ipv6 Ping over Link Local address via the Port based routing interface is failed.")
report_flag = 1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.vlan_in_1):
st.log("Ipv6 Ping over Link Local address via the Vlan based routing interface is failed.")
report_flag =1
if not ip_obj.ping(vars.D1, d2_prt_link_local[0], family='ipv6', interface = data.prt_chnl):
st.log("Ipv6 Ping over Link Local address via the Port Channel based routing interface is failed.")
report_flag =1
utils.exec_all(True, [[get_mac, vars.D1] ,[get_mac, vars.D2]])
st.log("Checking the IPv6 traffic forwarding over ECMP next hops after remove and re adding of next hop interfaces")
tg1.tg_traffic_control(action='run', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
st.wait(data.pkts_tx_time)
tg1.tg_traffic_control(action='stop', handle=tg_str_data[1]["tg1_ipv6_data_str_id_1"])
ecmp_cntrs = verify_traffic_hash(vars.D1, [vars.D1D2P1, vars.D1D2P2, vars.D1D2P3, vars.D1D2P4], data.pkts_per_port)
st.log("Counter stats on next hop interfaces - {}".format(ecmp_cntrs))
traffic_details = {
'1': {
'tx_ports': [vars.T1D1P1],
'tx_obj': [tg1],
'exp_ratio': [1],
'rx_ports': [vars.T1D2P1],
'rx_obj': [tg2],
}
}
filter_result = tgapi.validate_tgen_traffic(traffic_details=traffic_details, mode='aggregate', comp_type='packet_count')
if not filter_result:
st.log("After flap in next hop interfaces, traffic loss observed for ipv6 traffic forwarded via ipv6 link local next hop")
report_flag = 1
if report_flag:
st.report_fail("ip6_traffic_over_link_local_nh_fail")
st.report_pass("test_case_passed")
def test_ft_vlan_delete_with_member():
"""
Author: Surendra Kumar Vella ([email protected])
Verify that user is not able to delete a valn till its members are deleted
"""
vars = st.ensure_min_topology("D1T1:1")
st.log(
"Adding TGen connected interfaces to newly created vlan in tagging mode."
)
if not vlan.add_vlan_member(vars.D1,
sc_data.vlan, [vars.D1D2P1],
tagging_mode=True,
cli_type=sc_data.cli_type):
st.report_fail("vlan_tagged_member_fail", vars.D1D2P1, sc_data.vlan)
st.log("checking whether vlan with member is deleted or not ")
if not st.is_community_build(vars.D1):
if vlan.delete_vlan(vars.D1, sc_data.vlan, cli_type="click"):
st.report_fail("vlan_deletion_successfull_albiet_having_member",
sc_data.vlan)
if not vlan.delete_vlan_member(
vars.D1, sc_data.vlan, vars.D1D2P1, cli_type=sc_data.cli_type):
st.report_fail("vlan_tagged_member_fail", vars.D1D2P1,
sc_data.vlan)
else:
if not vlan.delete_vlan(vars.D1, sc_data.vlan, cli_type="click"):
st.report_fail("vlan_delete_fail", sc_data.vlan)
st.log("deleting the vlan after its member deletion")
st.report_pass("test_case_passed")
def test_ft_add_unknownvlan_interface():
"""
Author: Surendra Kumar Vella ([email protected])
verify that DUT should not assign unknown pvid
"""
st.log(" Adding TGen connected interface {} to non-existing vlan {} with untagged mode".format(vars.D1D2P1,
sc_data.vlan_id))
if vlan.add_vlan_member(vars.D1, sc_data.vlan_id, [vars.D1D2P1], tagging_mode=False, skip_error=True):
st.report_fail("unknown_vlan_untagged_member_add_fail", vars.D1D2P1, sc_data.vlan_id)
if not vlan.add_vlan_member(vars.D1, sc_data.vlan, [vars.D1D2P1], tagging_mode=True):
st.report_fail("vlan_tagged_member_fail", vars.D1D2P1, sc_data.vlan)
if not vlan.delete_vlan_member(vars.D1, sc_data.vlan, vars.D1D2P1, tagging_mode=True):
st.report_fail("vlan_tagged_member_fail", vars.D1D2P1, sc_data.vlan)
st.report_pass("test_case_passed")
def vlan_preconfig():
if not vlan_obj.create_vlan(vars.D1, data.vlan):
st.report_fail("vlan_create_fail", data.vlan)
if not st.is_community_build():
mac_obj.config_mac(vars.D1, data.source_mac, data.vlan, vars.D1T1P1)
st.log(
"Adding TGen-1 connected interface to newly created vlan in un tagging mode."
)
if not vlan_obj.add_vlan_member(
vars.D1, data.vlan, vars.D1T1P1, tagging_mode=False):
st.report_fail("vlan_untagged_member_fail", vars.D1T1P1, data.vlan)
st.log(
"Adding TGen-2 connected interface to newly created vlan in tagging mode."
)
if not vlan_obj.add_vlan_member(
vars.D1, data.vlan, vars.D1T1P2, tagging_mode=True):
st.report_fail("vlan_untagged_member_fail", vars.D1T1P2, data.vlan)
def tf_module_config(config='yes'):
if config == 'yes':
tf_data.vlan = str(random_vlan_list()[0])
vapi.create_vlan(vars.D1, tf_data.vlan)
vapi.add_vlan_member(vars.D1,
tf_data.vlan,
port_list=tf_data.port_list,
tagging_mode=True)
tf_data.tg, tf_data.tg_ph_list, tf_data.stream_tf_data = tf_tg_stream_config(
)
tfapi.threshold_feature_debug(vars.D1, mode='port_map')
else:
vapi.delete_vlan_member(vars.D1,
tf_data.vlan,
port_list=tf_data.port_list,
tagging_mode=True)
vapi.delete_vlan(vars.D1, tf_data.vlan)
def ceta_31902_fixture(request, ip_module_hooks):
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ip6_addr[1],
96,
family=data.af_ipv6,
config="remove")
vlan_obj.create_vlan(vars.D1, [data.host1_vlan, data.host2_vlan])
vlan_obj.add_vlan_member(vars.D1,
data.host1_vlan, [vars.D1T1P1, vars.D1T1P2],
tagging_mode=True)
vlan_obj.add_vlan_member(vars.D1,
data.host2_vlan, [vars.D1T1P1, vars.D1T1P2],
tagging_mode=True)
ipfeature.config_ip_addr_interface(vars.D1,
"Vlan" + data.host1_vlan,
data.vlan1_ip,
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
"Vlan" + data.host2_vlan,
data.vlan2_ip,
24,
family=data.af_ipv4)
yield
ipfeature.delete_ip_interface(vars.D1,
"Vlan" + data.host1_vlan,
data.vlan1_ip,
"24",
family="ipv4")
ipfeature.delete_ip_interface(vars.D1,
"Vlan" + data.host2_vlan,
data.vlan2_ip,
"24",
family="ipv4")
vlan_obj.delete_vlan_member(vars.D1, data.host1_vlan,
[vars.D1T1P1, vars.D1T1P2], True)
vlan_obj.delete_vlan_member(vars.D1, data.host2_vlan,
[vars.D1T1P1, vars.D1T1P2], True)
vlan_obj.delete_vlan(vars.D1, [data.host1_vlan, data.host2_vlan])
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ip6_addr[1],
96,
family=data.af_ipv6)
def arp_module_hooks(request):
global vars, tg_handler, tg, dut1, d1_mac_addr, h1, h2
# Min topology verification
vars = st.ensure_min_topology("D1T1:2")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2")
tg = tg_handler["tg"]
# Test setup details
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
# Test variables
d1_mac_addr = mac.get_sbin_intf_mac(dut1, "eth0")
# ARP module configuration
st.log("ARP module configuration.")
ip_obj.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr, data.mask)
vlan_obj.create_vlan(dut1, data.vlan_1)
vlan_obj.add_vlan_member(dut1, data.vlan_1, vars.D1T1P2, True)
ip_obj.config_ip_addr_interface(dut1, data.vlan_int_1, data.d1t2_ip_addr, data.mask)
# TG ports reset
st.log("Resetting the TG ports")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
# TG protocol interface creation
st.log("TG protocol interface creation")
h1 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_1"], mode='config',
intf_ip_addr=data.t1d1_ip_addr,gateway=data.d1t1_ip_addr,
src_mac_addr=data.t1d1_mac_addr,arp_send_req='1')
st.log("INTFCONF: "+str(h1))
h2 = tg.tg_interface_config(port_handle=tg_handler["tg_ph_2"], mode='config',
intf_ip_addr=data.t2d1_ip_addr,gateway=data.d1t2_ip_addr,
src_mac_addr=data.t2d1_mac_addr,arp_send_req='1',vlan_id=data.vlan_1,vlan=1)
st.log("INTFCONF: "+str(h2))
yield
# ARP module cleanup
st.log("ARP module cleanup.")
ip_obj.clear_ip_configuration(dut1,family="ipv4",thread=data.clear_parallel)
vlan_obj.clear_vlan_configuration(dut1,thread= data.clear_parallel)
def vlan_config():
vlan_obj.create_vlan(vars.D1, data.vlan)
st.log(
"Adding TGen port connected interface to the vlan with tagging mode")
if not vlan_obj.add_vlan_member(vars.D1,
data.vlan,
[vars.D1T1P1, vars.D1T1P2, vars.D1T1P3],
tagging_mode=True):
st.report_fail("vlan_tagged_member_fail")
if not vlan_obj.verify_vlan_brief(vars.D1, data.vlan):
st.report_fail("vlan_create_fail", data.vlan)
def interface_module_hooks(request):
global vars
vars = st.ensure_min_topology("D1D2:2", "D1T1:2")
initialize_variables()
if not vlanapi.create_vlan(vars.D1, intf_data.vlan_id):
st.report_fail("vlan_create_fail", intf_data.vlan_id)
if not vlanapi.add_vlan_member(vars.D1, intf_data.vlan_id, [vars.D1T1P1, vars.D1T1P2]):
st.report_fail("vlan_untagged_member_fail", [vars.D1T1P1, vars.D1T1P2], intf_data.vlan_id)
st.log("Getting TG handlers")
_, intf_data.tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
_, intf_data.tg_ph_2 = tgapi.get_handle_byname("T1D1P2")
intf_data.tg = tgapi.get_chassis(vars)
st.log("Reset and clear statistics of TG ports")
intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
intf_data.tg.tg_traffic_control(action='clear_stats', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
st.log("Creating TG streams")
intf_data.streams = {}
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2,
length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu1,
l2_encap='ethernet_ii_vlan', transmit_mode='single_burst',
pkts_per_burst=100, vlan_id=intf_data.vlan_id,
mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac,
vlan="enable")
st.log('Stream output:{}'.format(stream))
intf_data.streams['mtu1'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create', port_handle2=intf_data.tg_ph_2,
length_mode='fixed', rate_pps=100, frame_size=intf_data.mtu2,
l2_encap='ethernet_ii_vlan', transmit_mode='single_burst',
pkts_per_burst=100, vlan_id=intf_data.vlan_id,
mac_src=intf_data.source_mac, mac_dst=intf_data.destination_mac,
vlan="enable")
st.log('Stream output:{}'.format(stream))
intf_data.streams['mtu2'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_1, mode='create',
length_mode='fixed', frame_size='5000',
transmit_mode='continuous')
st.log('Stream output:{}'.format(stream))
intf_data.streams['traffic_tg1'] = stream['stream_id']
stream = intf_data.tg.tg_traffic_config(port_handle=intf_data.tg_ph_2, mode='create',
length_mode='fixed', frame_size='5000',
transmit_mode='continuous')
st.log('Stream output:{}'.format(stream))
intf_data.streams['traffic_tg2'] = stream['stream_id']
yield
vlanapi.clear_vlan_configuration(st.get_dut_names(), thread=True)
# intf_data.tg.tg_traffic_control(action='stop', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
intf_data.tg.tg_traffic_control(action='reset', port_handle=[intf_data.tg_ph_1, intf_data.tg_ph_2])
def vlan_config():
st.log("creating random vlan")
if not vlan_obj.create_vlan(vars.D1, data.vlan):
st.report_fail("vlan_create_fail", data.vlan)
else:
st.log("vlan creation is successful")
st.log(
"Adding Ixia port connected interface to the vlan with tagging mode")
if not vlan_obj.add_vlan_member(
vars.D1, data.vlan, [vars.D1T1P1, vars.D1T1P2], tagging_mode=True):
st.report_fail("vlan_tagged_member_fail", [vars.D1T1P1, vars.D1T1P2],
data.vlan)
else:
st.log("Adding ports in the vlan is successful")
def test_ft_stormcontrol_portchannel_intf():
status = 1
msg_id = "storm_control_portchannel_verification_successful"
portchannel_name = 'PortChannel13'
vlan_info = [{
"dut": [vars.D2],
"vlan_id": sc_data.vlan,
"tagged": [vars.D2T1P1, vars.D2T1P2, portchannel_name]
}]
portchannel_interfaces_dut1 = [vars.D1D2P1, vars.D1D2P2]
portchannel_interfaces_dut2 = [vars.D2D1P1, vars.D2D1P2]
portchannel.config_portchannel(vars.D1,
vars.D2,
portchannel_name,
portchannel_interfaces_dut1,
portchannel_interfaces_dut2,
config="add",
thread=True)
vlan.add_vlan_member(vars.D1,
sc_data.vlan,
portchannel_name,
tagging_mode=True)
vlan.create_vlan_and_add_members(vlan_info)
st.log(
"Verifying whether stormcontrol config can be applied on portchannel {} interfaces"
.format(portchannel_name))
if scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=portchannel_name,
rate=sc_data.kbps,
skip_error_check=True):
st.error(
"storm-control config can be applied on portchannel interface")
status = 0
else:
st.log(
"storm-control config cannot be applied on portchannel interface.")
if status:
st.report_tc_pass('ft_stormcontrol_neg_config_vlan_portchannel',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_config_vlan_portchannel',
'test_case_failed')
status = 1
st.log("configuring bum stormcontrol on portchannel interfaces")
scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P2,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="add",
interface_name=vars.D2D1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="add",
interface_name=vars.D2D1P2,
bits_per_sec=sc_data.kbps)
verify_bum_traffic_mode('broadcast',
tg_info['tg1_stream_id'],
skip_traffic_verify=True)
st.log("Clearing interface counters")
ifapi.clear_interface_counters(vars.D2)
tg.tg_traffic_control(action='run',
stream_handle=tg_info['tg1_stream_id'],
duration=10)
st.wait(sc_data.wait_stream_run)
st.log("Stopping of traffic from TGen to get interface counters")
tg.tg_traffic_control(action='stop',
stream_handle=tg_info['tg1_stream_id'])
st.wait(sc_data.wait_for_stats)
tg_1_stats = tgapi.get_traffic_stats(tg,
mode='aggregate',
port_handle=tg_handler["tg_ph_1"])
tg_3_stats = tgapi.get_traffic_stats(tg,
mode='aggregate',
port_handle=tg_handler["tg_ph_3"])
counter = tg_3_stats.rx.total_packets
counter2 = tg_1_stats.tx.total_packets
try:
time = int(counter2 / sc_data.rate_pps)
counters_avg = counter / time
except Exception:
counters_avg = 0
st.log("Average of counters are : {}".format(counters_avg))
st.log("Higher packet count value is : {}".format(
sc_data.higher_pkt_count))
st.log("Lower packet count value is : {}".format(sc_data.lower_pkt_count))
st.log("value of status is : {}".format(status))
if counters_avg > sc_data.higher_pkt_count or counters_avg < sc_data.lower_pkt_count:
st.error("storm control traffic verification failed")
status = 0
if status:
st.report_tc_pass('ft_stormcontrol_portchannel_intf',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_portchannel_intf',
'test_case_failed')
status = 1
st.log("Configuring stormcontrol without providing bps value")
if scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P1,
skip_error_check=True):
st.error("Storm-control config is accepting not throwing any error")
status = 0
else:
st.log("Config is not accepted and thrown an error")
if status:
st.report_tc_pass('ft_stormcontrol_neg_config_without_bpsvalue',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_config_without_bpsvalue',
'test_case_failed')
status = 1
st.log("unconfiguring of bum stormcontrol type by providing bps value")
if scapi.config(vars.D1,
type="broadcast",
action="del",
interface_name=vars.D1T1P1,
rate=sc_data.kbps,
skip_error_check=True):
st.error("Storm-control config is removed and not throwing any error")
status = 0
else:
st.log("Config is not accepted and thrown an error")
if status:
st.report_tc_pass('ft_stormcontrol_neg_unconfig_with_bpsvalue',
'test_case_passed')
else:
st.report_tc_fail('ft_stormcontrol_neg_unconfig_with_bpsvalue',
'test_case_failed')
st.log("Back to module config")
scapi.config(vars.D2,
type="broadcast",
action="del",
interface_name=vars.D2D1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D2,
type="broadcast",
action="del",
interface_name=vars.D2D1P2,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P1,
bits_per_sec=sc_data.kbps)
scapi.config(vars.D1,
type="broadcast",
action="add",
interface_name=vars.D1T1P2,
bits_per_sec=sc_data.kbps)
st.log(
"Unconfiguring portchannel config in both devices and only vlan configuration in device2"
)
vlan.clear_vlan_configuration(vars.D2)
vlan.delete_vlan_member(vars.D1,
sc_data.vlan,
portchannel_name,
tagging_mode=True)
portchannel.clear_portchannel_configuration(st.get_dut_names(),
thread=True)
if not status:
msg_id = "storm_control_portchannel_verification_failed"
report_result(status, msg_id)
def dut2_config(config=''):
st.log('On DUT2 add IPv4 and IPv6 addresses to physical interface')
ip_obj.config_ip_addr_interface(data.dut2_server, data.d2_d1_ports[0],
data.dut2_dut1_ipv6[0],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server, data.d2_d1_ports[0],
data.dut2_dut1_ip[0],
data.dut2_dut1_ip_subnet, 'ipv4')
st.log('On DUT2 configure vlan and add IPv4 and IPv6 addresses to it')
vlan_obj.create_vlan(data.dut2_server, data.dut1_dut2_vlan[0])
vlan_obj.add_vlan_member(data.dut2_server, data.dut1_dut2_vlan[0],
data.d2_d1_ports[1], True, True)
ip_obj.config_ip_addr_interface(data.dut2_server,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ipv6[1],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server,
'Vlan' + data.dut1_dut2_vlan[0],
data.dut2_dut1_ip[1],
data.dut2_dut1_ip_subnet, 'ipv4')
st.log(
'On DUT2 configure portchannel and add IPv4 and IPv6 addresses to it')
pc_obj.create_portchannel(data.dut2_server, data.portchannel)
pc_obj.add_portchannel_member(data.dut2_server, data.portchannel,
[data.d2_d1_ports[2], data.d2_d1_ports[3]])
ip_obj.config_ip_addr_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ipv6[2],
data.dut2_dut1_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server, data.portchannel,
data.dut2_dut1_ip[2],
data.dut2_dut1_ip_subnet, 'ipv4')
st.log('On DUT2 configure loopback and add IPv4 and IPv6 addresses to it')
ip_obj.configure_loopback(data.dut2_server,
config='yes',
loopback_name=data.dut2_loopback[0])
ip_obj.config_ip_addr_interface(data.dut2_server, data.dut2_loopback[0],
data.dut2_loopback_ipv6[0],
data.dut2_loopback_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server, data.dut2_loopback[0],
data.dut2_loopback_ip[0],
data.dut2_loopback_ip_subnet, 'ipv4')
st.log('IPv4 and IPv6 static routes for loopback reachability')
ip_obj.create_static_route(data.dut2_server,
data.dut1_dut2_ip[0],
data.dut1_loopback_ip[0] + '/32',
family='ipv4')
ip_obj.create_static_route(data.dut2_server,
data.dut1_dut2_ipv6[0],
data.dut1_loopback_ipv6[0] + '/128',
family='ipv6')
####
ip_obj.config_ip_addr_interface(data.dut2_server, data.d2_d3_ports[0],
data.dut2_dut3_ip[0],
data.dut2_dut3_ip_subnet, 'ipv4')
ip_obj.config_ip_addr_interface(data.dut2_server, data.d2_d3_ports[0],
data.dut2_dut3_ipv6[0],
data.dut2_dut3_ipv6_subnet, 'ipv6')
vlan_obj.create_vlan(data.dut2_server, data.dut2_dut3_vlan[0])
vlan_obj.add_vlan_member(data.dut2_server, data.dut2_dut3_vlan[0],
data.d2_d3_ports[1], True, True)
ip_obj.config_ip_addr_interface(data.dut2_server,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut2_dut3_ipv6[1],
data.dut2_dut3_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut2_dut3_ip[1],
data.dut2_dut3_ip_subnet, 'ipv4')
st.log('On DUT2 configure portchannel and IPv4 and IPv6 addresses on it')
pc_obj.create_portchannel(data.dut2_server, data.portchannel_2)
pc_obj.add_portchannel_member(data.dut2_server, data.portchannel_2,
[data.d2_d3_ports[2], data.d2_d3_ports[3]])
ip_obj.config_ip_addr_interface(data.dut2_server, data.portchannel_2,
data.dut2_dut3_ipv6[2],
data.dut2_dut3_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server, data.portchannel_2,
data.dut2_dut3_ip[2],
data.dut2_dut3_ip_subnet, 'ipv4')
st.log('On DUT2 configure loopback and IPv4 and IPv6 addresses on it')
ip_obj.configure_loopback(data.dut2_server,
config='yes',
loopback_name=data.dut2_loopback[1])
ip_obj.config_ip_addr_interface(data.dut2_server, data.dut2_loopback[1],
data.dut2_loopback_ipv6[1],
data.dut2_loopback_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut2_server, data.dut2_loopback[1],
data.dut2_loopback_ip[1],
data.dut2_loopback_ip_subnet, 'ipv4')
st.log('IPv4 and IPv6 static routes for loopback reachability')
ip_obj.create_static_route(data.dut2_server,
data.dut3_dut2_ip[0],
data.dut3_loopback_ip[0] + '/32',
family='ipv4')
ip_obj.create_static_route(data.dut2_server,
data.dut3_dut2_ipv6[0],
data.dut3_loopback_ipv6[0] + '/128',
family='ipv6')
return True
def dut3_config(config=''):
st.log('On DUT3 physical interface IPv4 and IPv6 addresses on it')
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
intf_name=data.d3_d2_ports[0],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.d3_d2_ports[0],
data.dut3_dut2_ipv6[0],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.d3_d2_ports[0],
data.dut3_dut2_ip[0],
data.dut3_dut2_ip_subnet, 'ipv4')
vlan_obj.create_vlan(data.dut3_client, data.dut2_dut3_vlan[0])
vlan_obj.add_vlan_member(data.dut3_client, data.dut2_dut3_vlan[0],
data.d3_d2_ports[1], True, True)
st.log('On DUT3 configure vlan and IPv4 and IPv6 addresses on it')
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_vlan,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_vlan,
intf_name='Vlan' + data.dut2_dut3_vlan[0],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut3_dut2_ipv6[1],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client,
'Vlan' + data.dut2_dut3_vlan[0],
data.dut3_dut2_ip[1],
data.dut3_dut2_ip_subnet, 'ipv4')
st.log('On DUT3 configure portchannel and IPv4 and IPv6 addresses on it')
pc_obj.create_portchannel(data.dut3_client, data.portchannel_2)
pc_obj.add_portchannel_member(data.dut3_client, data.portchannel_2,
[data.d3_d2_ports[2], data.d3_d2_ports[3]])
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_pc,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_pc,
intf_name=data.portchannel_2,
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.portchannel_2,
data.dut3_dut2_ipv6[2],
data.dut3_dut2_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.portchannel_2,
data.dut3_dut2_ip[2],
data.dut3_dut2_ip_subnet, 'ipv4')
st.log('On DUT3 configure loopback and IPv4 and IPv6 addresses on it')
ip_obj.configure_loopback(data.dut3_client,
config='yes',
loopback_name=data.dut3_loopback[1])
vrf_obj.config_vrf(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
config='yes')
vrf_obj.bind_vrf_interface(dut=data.dut3_client,
vrf_name=data.dut3_vrf_phy,
intf_name=data.dut3_loopback[1],
config='yes')
ip_obj.config_ip_addr_interface(data.dut3_client, data.dut3_loopback[1],
data.dut3_loopback_ipv6[1],
data.dut3_loopback_ipv6_subnet, 'ipv6')
ip_obj.config_ip_addr_interface(data.dut3_client, data.dut3_loopback[1],
data.dut3_loopback_ip[1],
data.dut3_loopback_ip_subnet, 'ipv4')
st.log('IPv4 and IPv6 static routes for loopback reachability')
ip_obj.create_static_route(data.dut3_client,
data.dut2_dut3_ip[0],
data.dut2_loopback_ip[1] + '/32',
family='ipv4',
interface=data.d3_d2_ports[0],
vrf=data.dut3_vrf_phy)
ip_obj.create_static_route(data.dut3_client,
data.dut2_dut3_ipv6[0],
data.dut2_loopback_ipv6[1] + '/128',
family='ipv6',
interface=data.d3_d2_ports[0],
vrf=data.dut3_vrf_phy)
return True
def dut2_config():
result = True
st.log('On DUT2 configure loopback')
result = ip_obj.configure_loopback(data.dut2,
config='yes',
loopback_name=[
data.dut2_loopback[0],
data.dut2_loopback[1],
data.dut2_loopback[2]
])
st.log('On DUT2 configure vlan')
result = vlan_obj.create_vlan(data.dut2, data.dut1_dut2_vlan[0])
result = vlan_obj.add_vlan_member(data.dut2, data.dut1_dut2_vlan[0],
data.d2_d1_ports[1], True, True)
st.log('On DUT2 configure portchannel')
result = pc_obj.create_portchannel(data.dut2, data.portchannel)
result = pc_obj.add_portchannel_member(
data.dut2, data.portchannel,
[data.d2_d1_ports[2], data.d2_d1_ports[3]])
st.log(
'On DUT2 configure OSPF router ID, ospf networks and add all the ospf interfaces'
)
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[0],
data.dut2_loopback_ipv6[0],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[0],
data.dut2_loopback_ip[0],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[1],
data.dut2_loopback_ipv6[1],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[1],
data.dut2_loopback_ip[1],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[2],
data.dut2_loopback_ipv6[2],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_loopback[2],
data.dut2_loopback_ip[2],
data.ip_loopback_prefix, 'ipv4')
st.log(
'On DUT2 configure OSPF router ID, ospf networks and add all the ospf interfaces'
)
result = ospf_obj.config_ospf_router_id(data.dut2,
data.dut2_ospf_router_id,
'default', '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut2, data.dut2_loopback_ip[0] + '/' + data.ip_loopback_prefix, 0,
'default', '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut2, data.dut2_loopback_ip[1] + '/' + data.ip_loopback_prefix, 0,
'default', '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut2, data.dut2_loopback_ip[2] + '/' + data.ip_loopback_prefix, 0,
'default', '', 'yes')
result = ospf_obj.config_ospf_network(data.dut2, data.dut2_tg1_network_v4,
0, 'default', '', 'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, data.d2_d1_ports[0], 'point-to-point', 'default', 'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
'default', 'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut2, data.portchannel, 'point-to-point', 'default', 'yes')
st.log('On DUT2 configure IP addresses on DUT2 - TG interfaces')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_tg_ports[0],
data.dut2_tg_ipv6[0],
data.tg_ipv6_subnet, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut2, data.dut2_tg_ports[0],
data.dut2_tg_ip[0],
data.tg_ip_subnet, 'ipv4')
result = arp_obj.add_static_arp(data.dut2, data.tg_dut2_ip[0],
'00:00:33:33:33:01', data.dut2_tg_ports[0])
return result
def config_ip(config='yes'):
if config == 'yes':
api_name = ip_api.config_ip_addr_interface
config_str = "Configure"
else:
api_name = ip_api.delete_ip_interface
config_str = "Delete"
hdrMsg("Bring-up the port on dut3 which is connected to dhcp server ")
interface_api.interface_operation(data.dut3,
data.dhcp_server_port,
operation="startup")
##########################################################################
hdrMsg(
"IP-config: {} IP address between dut2 interface {} and dut3 interface {}"
.format(config_str, data.d2d3_ports, data.d3d2_ports))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut2, data.d2d3_ports[0], dut2_3_ip_list[0], mask_24
], [api_name, data.dut3, data.d3d2_ports[0], dut3_2_ip_list[0], mask_24]])
if config == 'yes':
st.banner('Install L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp')
##########################################################################
hdrMsg("Create loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback,
[{
'loopback_name': 'Loopback1'
}] * 3)
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################
hdrMsg("config required vlan to test on dut2 and dut4")
##########################################
utils.exec_all(True, [[vlan_api.create_vlan, data.dut2, ['100']],
[vlan_api.create_vlan, data.dut4, ['100']]])
vlan_api.create_vlan(data.dut4, ['200', '300'])
##########################################
hdrMsg("Add vlan members")
##########################################
utils.exec_all(True, [[
vlan_api.add_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.add_vlan_member, data.dut4, '100',
data.d4d2_ports[0], True
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut2 and dut4")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut2, ['PortChannel12']],
[pc.create_portchannel, data.dut4, ['PortChannel12']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'add'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'add'
]])
#########################################################
hdrMsg("LAG-Config: Create portchannel on dut3 and dut1")
#########################################################
utils.exec_all(True,
[[pc.create_portchannel, data.dut3, ['PortChannel14']],
[pc.create_portchannel, data.dut1, ['PortChannel14']]])
#########################################################
hdrMsg("LAG-Config: add member ports to portchannel")
#########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'add'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'add'
]])
ip_api.config_ip_addr_interface(data.dut2, 'Vlan100',
dut2_4_ip_list[0], mask_24)
ip_api.config_ip_addr_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.config_ip_addr_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.config_ip_addr_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
#########################################
hdrMsg("Add vlan members on DUT4")
#########################################
vlan_api.add_vlan_member(data.dut4, '200', data.d4d2_ports[1])
vlan_api.add_vlan_member(data.dut4, '300', 'PortChannel12')
st.exec_all([[create_static_route_dut2], [create_static_route_dut3]])
else:
st.banner('Remove L2 DHCP rules on dhcp client device')
copp_api.bind_class_action_copp_policy(data.dut4,
classifier='copp-system-dhcpl2',
action_group='copp-system-dhcp',
config='no')
##########################################################################
hdrMsg("Loopback-config: {} IP address on Loopback interface".format(
config_str))
##########################################################################
utils.exec_all(True, [[
api_name, data.dut1, "Loopback1", dut1_loopback_ip_list[0], '32'
], [
api_name, data.dut2, "Loopback1", dut2_loopback_ip_list[0], '32'
], [api_name, data.dut3, "Loopback1", dut3_loopback_ip_list[0], '32']])
##########################################################################
hdrMsg("Delete loopback interfaces on dut1, dut2 and dut3")
##########################################################################
parallel.exec_parallel(True, [data.dut1, data.dut2, data.dut3],
ip_api.configure_loopback, [{
'loopback_name': 'Loopback1',
'config': 'no'
}] * 3)
st.exec_all([[delete_static_route_dut2], [delete_static_route_dut3]])
hdrMsg(" Remove all ip configs on dut2")
ip_api.delete_ip_interface(data.dut2, 'Vlan100', dut2_4_ip_list[0],
mask_24)
ip_api.delete_ip_interface(data.dut2, data.d2d4_ports[1],
dut2_4_ip_list[1], mask_24)
ip_api.delete_ip_interface(data.dut2, 'PortChannel12',
dut2_4_ip_list[2], mask_24)
ip_api.delete_ip_interface(data.dut1,
'PortChannel14',
data.dhcp_server_ipv6,
mask_v6,
family='ipv6')
###########################################################
hdrMsg("LAG-unConfig: delete member ports to portchannel")
###########################################################
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut2, 'PortChannel12',
data.d2d4_ports[2], 'del'
],
[
pc.add_del_portchannel_member, data.dut4,
'PortChannel12', data.d4d2_ports[2], 'del'
]])
utils.exec_all(True, [[
pc.add_del_portchannel_member, data.dut3, 'PortChannel14',
data.d3d1_ports[0], 'del'
],
[
pc.add_del_portchannel_member, data.dut1,
'PortChannel14', data.d1d3_ports[0], 'del'
]])
vlan_api.delete_vlan_member(data.dut4, '300', 'PortChannel12')
#######################################################
hdrMsg("LAG-UnConfig: Delete portchannel on dut2 and dut4")
#######################################################
utils.exec_all(True,
[[pc.delete_portchannel, data.dut2, ['PortChannel12']],
[pc.delete_portchannel, data.dut4, ['PortChannel12']]])
utils.exec_all(True,
[[pc.delete_portchannel, data.dut3, ['PortChannel14']],
[pc.delete_portchannel, data.dut1, ['PortChannel14']]])
########################################
hdrMsg("Delete vlan member ports")
########################################
utils.exec_all(True, [[
vlan_api.delete_vlan_member, data.dut2, '100', data.d2d4_ports[0],
True
],
[
vlan_api.delete_vlan_member, data.dut4,
'100', data.d4d2_ports[0], True
]])
vlan_api.delete_vlan_member(data.dut4, '200', data.d4d2_ports[1])
####################################
hdrMsg("Unconfig vlan fron dut2 and dut4")
###################################
utils.exec_all(True, [[vlan_api.delete_vlan, data.dut2, ['100']],
[vlan_api.delete_vlan, data.dut4, ['100']]])
vlan_api.delete_vlan(data.dut4, ['200', '300'])
def dut_vrf_bind(**kwargs):
vars = st.get_testbed_vars()
dut1 = st.get_dut_names()[0]
dut2 = st.get_dut_names()[1]
if 'config' in kwargs:
config = kwargs['config']
else:
config = ''
if config == '':
st.log(
'######------Configure vlans on the PE--PE side - DUT1 -- DUT2------######'
)
for vlan in data.dut1_dut2_vlan[0:3]:
vlan_obj.create_vlan(dut1, vlan)
vlan_obj.add_vlan_member(dut1, vlan, vars.D1D2P1, True, True)
for vlan in data.dut2_dut1_vlan[0:3]:
vlan_obj.create_vlan(dut2, vlan)
vlan_obj.add_vlan_member(dut2, vlan, vars.D2D1P1, True, True)
st.log(
'######------Bind DUT1 <--> DUT2 vlans to vrf, assign v4 and v6 address------######'
)
for vlan, ip, ip2, ipv6, ipv6_2, vrf in zip(
data.dut1_dut2_vlan[0:3], data.dut1_dut2_vrf_ip[0:3],
data.dut2_dut1_vrf_ip[0:3], data.dut1_dut2_vrf_ipv6[0:3],
data.dut2_dut1_vrf_ipv6[0:3], data.vrf_name[0:3]):
dict1 = {
'vrf_name': vrf,
'intf_name': 'Vlan' + vlan,
'skip_error': True
}
dict2 = {
'vrf_name': vrf,
'intf_name': 'Vlan' + vlan,
'skip_error': True
}
parallel.exec_parallel(True, [dut1, dut2],
vrf_api.bind_vrf_interface, [dict1, dict2])
parallel.exec_all(
True,
[[
ipfeature.config_ip_addr_interface, dut1, 'Vlan' + vlan,
ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4'
],
[
ipfeature.config_ip_addr_interface, dut2, 'Vlan' + vlan,
ip2, data.dut2_dut1_vrf_ip_subnet, 'ipv4'
]])
parallel.exec_all(
True,
[[
ipfeature.config_ip_addr_interface, dut1, 'Vlan' + vlan,
ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6'
],
[
ipfeature.config_ip_addr_interface, dut2, 'Vlan' + vlan,
ipv6_2, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6'
]])
'''
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(dut1, 'Vlan'+vlan, ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6')
'''
'''
st.log('######------Bind DUT2 <--> DUT1 virtual interfaces to vrf and config IP addresses------######')
for vlan, ip, ipv6, vrf in zip(data.dut2_dut1_vlan[0:3], data.dut2_dut1_vrf_ip[0:3], data.dut2_dut1_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True)
ipfeature.config_ip_addr_interface(dut2, 'Vlan'+vlan, ip, data.dut2_dut1_vrf_ip_subnet, 'ipv4')
ipfeature.config_ip_addr_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6')
'''
elif config == 'no':
'''
st.log('######------Unbind DUT1 <--> DUT2 vlans to vrf, assign v4 and v6 address------######')
for vlan, ip, ipv6, vrf in zip(data.dut1_dut2_vlan[0:3], data.dut1_dut2_vrf_ip[0:3], data.dut1_dut2_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut1, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ip, data.dut1_dut2_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut1, 'Vlan'+vlan, ipv6, data.dut1_dut2_vrf_ipv6_subnet, 'ipv6')
st.log('######------Unbind DUT2 <--> DUT1 physical interfaces to vrf and config IP addresses------######')
for vlan, ip, ipv6, vrf in zip(data.dut2_dut1_vlan[0:3], data.dut2_dut1_vrf_ip[0:3], data.dut2_dut1_vrf_ipv6[0:3],data.vrf_name[0:3]):
vrf_api.bind_vrf_interface(dut = dut2, vrf_name = vrf, intf_name = 'Vlan'+vlan, skip_error = True, config = 'no')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ip, data.dut2_dut1_vrf_ip_subnet, 'ipv4')
ipfeature.delete_ip_interface(dut2, 'Vlan'+vlan, ipv6, data.dut2_dut1_vrf_ipv6_subnet, 'ipv6')
'''
st.log(
'######------Delete vlans on the PE--PE side - DUT1 -- DUT2------######'
)
for vlan in data.dut1_dut2_vlan[0:3]:
vlan_obj.delete_vlan_member(dut1,
vlan,
vars.D1D2P1,
tagging_mode=True)
vlan_obj.delete_vlan(dut1, vlan)
for vlan in data.dut2_dut1_vlan[0:3]:
vlan_obj.delete_vlan_member(dut2,
vlan,
vars.D2D1P1,
tagging_mode=True)
vlan_obj.delete_vlan(dut2, vlan)
def dut1_config():
result = True
st.log('On DUT1 configure vrfs and loopbacks')
result = vrf_obj.config_vrf(dut=data.dut1,
vrf_name=data.dut1_vrf[0],
config='yes')
result = ip_obj.configure_loopback(data.dut1,
config='yes',
loopback_name=[
data.dut1_loopback[0],
data.dut1_loopback[1],
data.dut1_loopback[2]
])
st.log('On DUT1 configure vlan')
result = vlan_obj.create_vlan(data.dut1, data.dut1_dut2_vlan[0])
result = vlan_obj.add_vlan_member(data.dut1, data.dut1_dut2_vlan[0],
data.d1_d2_ports[1], True, True)
st.log('On DUT1 configure portchannel')
result = pc_obj.create_portchannel(data.dut1, data.portchannel)
result = pc_obj.add_portchannel_member(
data.dut1, data.portchannel,
[data.d1_d2_ports[2], data.d1_d2_ports[3]])
st.log(
'On DUT1 bind all the loopbacks, physical, vlan and portchannel interfaces between the DUTs to the VRF'
)
result = vrf_obj.bind_vrf_interface(
dut=data.dut1,
vrf_name=[
data.dut1_vrf[0], data.dut1_vrf[0], data.dut1_vrf[0],
data.dut1_vrf[0], data.dut1_vrf[0], data.dut1_vrf[0],
data.dut1_vrf[0], data.dut1_vrf[0]
],
intf_name=[
data.dut1_tg_ports[0], data.dut1_loopback[0],
data.dut1_loopback[1], data.dut1_loopback[2], data.d1_d2_ports[0],
'Vlan' + data.dut1_dut2_vlan[0], data.portchannel
],
config='yes')
st.banner('On DUT1 verify vrf bindings for all the interfaces')
output = vrf_obj.get_vrf_verbose(dut=data.dut1, vrfname=data.dut1_vrf[0])
if data.dut1_vrf[0] in output['vrfname']:
st.log('VRF configured on DUT1 is as expected', data.dut1_vrf[0])
else:
st.error('VRF name configured on DUT1 is as not expected',
data.dut1_vrf[0])
result = False
for value in output['interfaces']:
if data.dut1_tg_ports[0] or data.dut1_loopback[
0] or data.dut1_loopback[1] or data.dut1_loopback[
2] or data.d1_d2_ports[0] or 'Vlan' + data.dut1_dut2_vlan[
0] or data.portchannel == value:
st.log('Bind to VRF is as expected', value)
else:
st.error('Bind to VRF is not as expected', value)
result = False
st.log(
'On DUT1 configure OSPF router ID, ospf networks and add all the ospf interfaces'
)
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ipv6[0],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[0],
data.dut1_loopback_ip[0],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ipv6[1],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[1],
data.dut1_loopback_ip[1],
data.ip_loopback_prefix, 'ipv4')
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ipv6[2],
data.ipv6_loopback_prefix, 'ipv6')
result = ip_obj.config_ip_addr_interface(data.dut1, data.dut1_loopback[2],
data.dut1_loopback_ip[2],
data.ip_loopback_prefix, 'ipv4')
st.log(
'On DUT1 configure OSPF router ID, ospf networks and add all the ospf interfaces'
)
result = ospf_obj.config_ospf_router_id(data.dut1,
data.dut1_ospf_router_id,
data.dut1_vrf[0], '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[0] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[1] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'yes')
result = ospf_obj.config_ospf_network(
data.dut1, data.dut1_loopback_ip[2] + '/' + data.ip_loopback_prefix, 0,
data.dut1_vrf[0], '', 'yes')
result = ospf_obj.config_ospf_network(data.dut1, data.dut1_tg1_network_v4,
0, data.dut1_vrf[0], '', 'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, data.d1_d2_ports[0], 'point-to-point', data.dut1_vrf[0],
'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, 'Vlan' + data.dut1_dut2_vlan[0], 'point-to-point',
data.dut1_vrf[0], 'yes')
result = ospf_obj.config_interface_ip_ospf_network_type(
data.dut1, data.portchannel, 'point-to-point', data.dut1_vrf[0], 'yes')
st.log('On DUT1 configure IP addresses on DUT - TG interfaces')
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_tg_ports[0],
data.dut1_tg_ipv6[0], data.tg_ipv6_subnet,
'ipv6')
ip_obj.config_ip_addr_interface(data.dut1, data.dut1_tg_ports[0],
data.dut1_tg_ip[0], data.tg_ip_subnet,
'ipv4')
return result
def test_ft_ip_v4_v6_L2_L3_translation():
# Objective - Verify that L2 port to IPv4 L3 port transition and vice-versa is successful.
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.log("L3 to L2 port transition")
st.log("Removing ipv4,ipv6 address from interface")
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.delete_ip_interface(vars.D1,
vars.D1T1P1,
data.ip4_addr[1],
24,
family=data.af_ipv4)
ipfeature.delete_ip_interface(vars.D2,
vars.D2T1P1,
data.ip4_addr[8],
24,
family=data.af_ipv4)
st.log("Removing the static routes")
ipfeature.delete_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
ipfeature.delete_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log("Vlan creation and port association configuration")
vlan_obj.create_vlan(vars.D1, data.vlan_2)
st.log("Adding back to back connecting ports to vlan {}".format(
data.vlan_2))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2, [vars.D1D2P4],
tagging_mode=True)
vlan_obj.create_vlan(vars.D2, data.vlan_2)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2, [vars.D2D1P4],
tagging_mode=True)
st.log("Adding TG connecting ports to vlan {}".format(data.vlan_1))
vlan_obj.add_vlan_member(vars.D1,
data.vlan_2,
vars.D1T1P1,
tagging_mode=True)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_2,
vars.D2T1P1,
tagging_mode=True)
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D2P1")
tg.tg_traffic_control(action="reset", port_handle=tg_handler["tg_ph_list"])
tg.tg_traffic_control(action="clear_stats",
port_handle=tg_handler["tg_ph_list"])
tr2 = tg.tg_traffic_config(port_handle=tg_handler["tg_ph_2"],
mode='create',
rate_pps="2000",
mac_src_mode="fixed",
transmit_mode="single_burst",
pkts_per_burst=2000,
length_mode='fixed',
l2_encap='ethernet_ii_vlan',
vlan_id=data.vlan_2,
mac_dst_mode="fixed",
vlan="enable",
mac_src="00:a1:bb:cc:dd:01",
mac_dst="00:b1:bb:cc:dd:01")
st.log("TRAFCONF: " + str(tr2))
res = tg.tg_traffic_control(action='run', stream_handle=tr2['stream_id'])
tg.tg_traffic_control(action='stop', stream_handle=tr2['stream_id'])
st.wait(data.wait_tgstats)
st.log("TR_CTRL: " + str(res))
st.log("Fetching TGen statistics")
stats_tg1 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_2"])
total_tx_tg1 = stats_tg1.tx.total_packets
stats_tg2 = tgapi.get_traffic_stats(tg_handler["tg"],
mode="aggregate",
port_handle=tg_handler["tg_ph_1"])
total_rx_tg2 = stats_tg2.rx.total_packets
st.log("total_tx_tg1 = {}".format(total_tx_tg1))
total_tx_tg1_95_percentage = int(total_tx_tg1) * 0.95
st.log("total_tx_tg1_95_percentage= {}".format(total_tx_tg1_95_percentage))
st.log("total_rx_tg2 = {}".format(total_rx_tg2))
if int(total_tx_tg1_95_percentage) > int(total_rx_tg2):
st.report_fail("traffic_verification_failed")
st.log("Removing vlan configuration")
vlan_obj.delete_vlan_member(vars.D1, data.vlan_2,
[vars.D1D2P4, vars.D1T1P1], True)
vlan_obj.delete_vlan_member(vars.D2, data.vlan_2,
[vars.D2D1P4, vars.D2T1P1], True)
st.log("L2 to L3 port transition")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.create_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
st.log("Checking IPv4 ping from {} to {} over routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D1, data.ip4_addr[7], family=data.af_ipv4, count=1):
st.report_fail("ping_fail", data.ip4_addr[6], data.ip4_addr[7])
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
st.log(
"Checking IPv6 ping from {} to {} over vlan routing interface".format(
vars.D1, vars.D2))
if not ipfeature.ping(
vars.D2, data.ip6_addr[6], family=data.af_ipv6, count=1):
st.report_fail("ping_fail", data.ip6_addr[7], data.ip6_addr[6])
st.report_pass("test_case_passed")
def ip_module_hooks(request):
global vars, tg_handler, tg
# Min topology verification
st.log("Ensuring minimum topology")
vars = st.ensure_min_topology("D1T1:4", "D2T1:2", "D1D2:4")
# Initialize TG and TG port handlers
tg_handler = tgapi.get_handles_byname("T1D1P1", "T1D1P2", "T1D2P1",
"T1D2P2")
tg = tg_handler["tg"]
# IP module configuration
st.log("Vlan routing configuration on D1D2P1,D2D1P1")
vlan_obj.create_vlan(vars.D1, data.vlan_1)
vlan_obj.add_vlan_member(vars.D1,
data.vlan_1, [vars.D1D2P1],
tagging_mode=True)
vlan_obj.create_vlan(vars.D2, data.vlan_1)
vlan_obj.add_vlan_member(vars.D2,
data.vlan_1, [vars.D2D1P1],
tagging_mode=True)
ipfeature.config_ip_addr_interface(vars.D1,
data.vlan_int_1,
data.ip4_addr[2],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
data.vlan_int_1,
data.ip6_addr[2],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
data.vlan_int_1,
data.ip4_addr[3],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
data.vlan_int_1,
data.ip6_addr[3],
96,
family=data.af_ipv6)
st.log("Port routing configuration on port-channel")
data.dut1_pc_members = [vars.D1D2P2, vars.D1D2P3]
data.dut2_pc_members = [vars.D2D1P2, vars.D2D1P3]
pc_obj.create_portchannel(vars.D1, data.port_channel)
pc_obj.add_portchannel_member(vars.D1, data.port_channel,
data.dut1_pc_members)
pc_obj.create_portchannel(vars.D2, data.port_channel)
pc_obj.add_portchannel_member(vars.D2, data.port_channel,
data.dut2_pc_members)
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip4_addr[4],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip4_addr[5],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
data.port_channel,
data.ip6_addr[4],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
data.port_channel,
data.ip6_addr[5],
96,
family=data.af_ipv6)
st.log("port routing configuration on D1D2P4,D2D1P4")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip4_addr[6],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip4_addr[7],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1D2P4,
data.ip6_addr[6],
96,
family=data.af_ipv6)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2D1P4,
data.ip6_addr[7],
96,
family=data.af_ipv6)
st.log("configuring the dut1 ports connected to TGen with ip addresses")
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P1,
data.ip4_addr[1],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D1,
vars.D1T1P2,
data.ip6_addr[1],
96,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.ip6_addr[7],
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
ipfeature.create_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
st.log("configuring the dut2 ports connected to TGen with ip addresses")
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2T1P1,
data.ip4_addr[8],
24,
family=data.af_ipv4)
ipfeature.config_ip_addr_interface(vars.D2,
vars.D2T1P2,
data.ip6_addr[8],
96,
family=data.af_ipv6)
yield
ipfeature.clear_ip_configuration(st.get_dut_names())
ipfeature.clear_ip_configuration(st.get_dut_names(), 'ipv6')
vlan_obj.clear_vlan_configuration(st.get_dut_names())
pc_obj.clear_portchannel_configuration(st.get_dut_names())
ipfeature.delete_static_route(vars.D1,
data.ip4_addr[7],
data.static_ip_rt,
shell=data.shell_vtysh,
family=data.af_ipv4)
ipfeature.delete_static_route(vars.D1,
data.static_ip6_rt_drop,
data.static_ip6_rt,
shell=data.shell_vtysh,
family=data.af_ipv6)
def test_l2_to_l3_port():
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
data.vlan = '10'
data.vlan_int = 'Vlan' + '10'
result_flag = 1
# configure from L3 to L2 port
vapi.create_vlan(dut1, data.vlan)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
ipfeature.config_ip_addr_interface(dut1, data.vlan_int, data.d1d2_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut1,
data.vlan_int,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
vapi.add_vlan_member(dut1, data.vlan, vars.D1D2P1, False)
if not vapi.verify_vlan_config(dut1, str(data.vlan), None, vars.D1D2P1):
result_flag = 0
ipfeature.get_interface_ip_address(dut1, family="ipv4")
ipfeature.get_interface_ip_address(dut1, family="ipv6")
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6, 'ipv6')
if not result1 or not result2:
result_flag = 0
# Revert back from L2 to L3 port
vapi.delete_vlan_member(dut1, data.vlan, [vars.D1D2P1])
ipfeature.delete_ip_interface(dut1, data.vlan_int, data.d1d2_ip_addr,
data.mask)
ipfeature.delete_ip_interface(dut1,
data.vlan_int,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
vapi.delete_vlan(dut1, [data.vlan])
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,
data.mask)
ipfeature.config_ip_addr_interface(dut1,
vars.D1D2P1,
data.d1d2_ip_addr_v6,
data.mask_v6,
family='ipv6')
waitapi.vsonic_ip_apply(vars.D1)
ping_result = ipfeature.ping(dut1, data.d2t1_ip_addr)
if ping_result and result_flag:
st.report_pass("operation_successful")
else:
st.report_fail("operation_failed")
def vlan_mem_cfg(dut, data):
if type(data) == list and len(data) > 0:
for vlan, port, mode in data:
vlan_obj.add_vlan_member(dut, vlan, port, tagging_mode=mode)
return True
return False
def portchannel_func_hooks(request):
yield
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_is_up_or_not_with_one_active_member':
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1[1:])
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_is_up_with_active_members_when_no_lag_in_partner':
portchannelobj.create_portchannel(vars.D2,
static_data.portchannel_name,
static=True)
portchannelobj.add_del_portchannel_member(vars.D2,
static_data.portchannel_name,
static_data.members_dut2)
add_vlan_member(vars.D2,
static_data.vid,
static_data.portchannel_name,
tagging_mode=True)
if st.get_func_name(
request
) == 'test_ft_verify_fallback_is_configure_or_not_on_static_portchannel':
if portchannelobj.get_portchannel(vars.D1,
static_data.portchannel_name2):
portchannelobj.delete_portchannel(vars.D1,
static_data.portchannel_name2)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_del_from_ip_assigned_vlan':
st.wait(2)
ipobj.config_ip_addr_interface(vars.D1,
'Vlan{}'.format(static_data.vid),
static_data.ip41,
static_data.ip_mask,
config='remove')
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1)
if st.get_func_name(request) == 'test_ft_del_ip_assigned_portchannel':
if not portchannelobj.get_portchannel(vars.D1,
static_data.portchannel_name):
portchannelobj.create_portchannel(vars.D1,
static_data.portchannel_name,
static=True)
ipobj.delete_ip_interface(vars.D1,
static_data.portchannel_name,
static_data.ip41,
static_data.ip_mask,
skip_error=True)
portchannelobj.add_del_portchannel_member(vars.D1,
static_data.portchannel_name,
static_data.members_dut1)
exceptions = exec_all(True,
[[
add_vlan_member, vars.D1, static_data.vid,
static_data.portchannel_name, True
],
[
add_vlan_member, vars.D2, static_data.vid,
static_data.portchannel_name, True
]])[1]
ensure_no_exception(exceptions)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_l3_hash_sip_dip_l4port':
arpobj.delete_static_arp(vars.D2,
static_data.ip42,
interface=vars.D2T1P1,
mac=static_data.remote_mac2)
ipobj.clear_ip_configuration([vars.D1, vars.D2],
family='ipv4',
thread=True)
exceptions = exec_all(
True, [[
add_vlan_member, vars.D1, static_data.vid,
[static_data.portchannel_name, vars.D1T1P1], True
],
[
add_vlan_member, vars.D2, static_data.vid,
[static_data.portchannel_name, vars.D2T1P1], True
]])[1]
ensure_no_exception(exceptions)
if st.get_func_name(
request
) == 'test_ft_verify_static_portchannel_vlan_routing_l3_traffic':
arpobj.delete_static_arp(vars.D2,
static_data.ip42,
interface=vars.D2T1P1,
mac=static_data.remote_mac2)
ipobj.clear_ip_configuration([vars.D1, vars.D2],
family='ipv4',
thread=True)
exceptions = exec_all(True, [[
add_vlan_member, vars.D1, static_data.vid, vars.D1T1P1, True
], [add_vlan_member, vars.D2, static_data.vid, vars.D2T1P1, True]])[1]
ensure_no_exception(exceptions)
