def erspan_func_hooks(request):
# add things at the start every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
yield
# add things at the end every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
# Deleteing configured ACL rule at end of each test case
if st.get_func_name(request) != 'test_ft_erspan_config_upload_save_reload_reboot':
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='del', policy_type=data.type,
class_name=data.acl_rule)
acl_dscp.config_classifier_table(dut=vars.D1, enable="del", class_name=data.acl_rule)
if 'test_ft_erspan_action_ethertype_dscp_tcp_flags_l4range' in request.node.name:
ip.delete_ip_interface(vars.D1, vars.D1T1P1, "2001:1::1", "64", family="ipv6")
ip.delete_ip_interface(vars.D1, vars.D1T1P2, "2001:2::1", "64", family="ipv6")
acl.delete_acl_rule(vars.D1, "L3_IPV6_INGRESS", "L3V6", "FWD_RULE1")
if st.get_func_name(request) == 'test_ft_erspan_action_encapsulation':
encap_list = ['0x88ee', '0x6558']
for encap in encap_list:
mirror.delete_session(vars.D1, "mirror_" + encap)
if st.get_func_name(request) == 'test_ft_erspan_portchannel_shut_noshut':
mirror.delete_session(vars.D1, data.mirror_session)
def erspan_post_config():
"""
Author: Lakshminarayana D ([email protected])
Using this post config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# Unconfig ip address on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.delete_ip_interface(vars.D1, port, ip_addr, data.subnet_mask)
# Unconfig ip address on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.delete_ip_interface(vars.D2, port, ip_addr, data.subnet_mask)
# Unconfig static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1, data.subnet_mask))
ip.delete_static_route(vars.D1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1, data.subnet_mask))
ip.delete_static_route(vars.D2, data.ip_D1D2P1, network)
# Unconfig mirror session
mirror.delete_session(vars.D1, data.session_name)
# Unconfig acl rule
acl_dscp.config_classifier_table(dut=vars.D1, enable="del", class_name=data.acl_rule)
# Unconfig acl table
acl_dscp.config_service_policy_table(dut=vars.D1, policy_kind='unbind', interface_name=vars.D1T1P1, stage='in',
service_policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_service_policy_table(dut=vars.D1, policy_kind='unbind', interface_name=vars.D1T1P2, stage='in',
service_policy_name=data.acl_table_name, policy_type=data.type)
acl_dscp.config_policy_table(dut=vars.D1, enable='del', policy_name=data.acl_table_name)
acl.delete_acl_table(vars.D1, acl_table_name="L3_IPV6_INGRESS", acl_type="L3V6")
def erspan_post_config():
"""
Author: Anil Kumar Kacharla<*****@*****.**>
Using this post config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# Unconfig ip address on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.delete_ip_interface(data.dut1, port, ip_addr, data.subnet_mask)
# Unconfig ip address on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.delete_ip_interface(data.dut2, port, ip_addr, data.subnet_mask)
# Unconfig static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1,
data.subnet_mask))
ip.delete_static_route(data.dut1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1,
data.subnet_mask))
ip.delete_static_route(data.dut2, data.ip_D1D2P1, network)
# Unconfig acl classifier
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='del',
policy_type=data.type,
class_name=data.acl_rule)
acl_dscp.config_classifier_table(dut=data.dut1,
enable="del",
class_name=data.acl_rule)
# Unconfig acl policy
acl_dscp.config_service_policy_table(
dut=data.dut1,
policy_kind='unbind',
interface_name=vars.D1T1P1,
stage='in',
service_policy_name=data.acl_table_name,
policy_type=data.type)
acl_dscp.config_policy_table(dut=data.dut1,
enable='del',
policy_name=data.acl_table_name)
# Unconfig mirror session
mirror.delete_session(data.dut1, data.session_name)
def test_ft_erspan_portchannel_shut_noshut():
"""
Author: Kanala Ramprakash Reddy ( [email protected])
TC1 FtOpSoSyErspanFn020: Verify that ERSPAN is working as expected after portchannel shut/no shut.
:return:
"""
st.log("############### Test started to check ERSPAN status between multiple link flaps###############")
st.log("Creating mirror session")
mirror.create_session(vars.D1, session_name=data.mirror_session, gre_type=data.gre_type, dscp=data.dscp,
ttl=data.ttl, queue=data.queue, src_ip=data.ip_T1D1P2, dst_ip=data.ip_T1D2P1)
st.log("Creating ACL Policy")
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria="--src-ip", class_name=data.acl_rule,
criteria_value=data.src_ip_mask, match_type="fields")
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type,
class_name=data.acl_rule, priority_value=data.priority,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update', policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value=data.mirror_action)
stream = data.tg1.tg_traffic_config(port_handle=data.tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed',
rate_pps=data.rate_pps, l2_encap='ethernet_ii', mac_src='00:0a:01:00:00:01',
mac_dst=dut_mac, l3_protocol="ipv4", ip_src_addr=data.ip_T1D1P1,
ip_dst_addr=data.ip_T1D1P2)['stream_id']
intf_obj.clear_interface_counters(vars.D1)
st.log("Starting the traffic")
data.tg1.tg_traffic_control(action='run', stream_handle=stream)
for _ in range(5):
intf_obj.interface_shutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="inactive",
session_name=data.mirror_session):
st.error("Mirror session status should be inactive after port shutdown")
data.flag = 0
intf_obj.interface_noshutdown(vars.D1, [vars.D1D2P1], skip_verify=True)
if not poll_wait(mirror.verify_session_all, 20, vars.D1, mirror_type="erspan", status="active",
session_name=data.mirror_session):
st.error("Mirror session status should be active after port startup")
data.flag = 0
data.tg1.tg_traffic_control(action='stop', stream_handle=stream)
if data.flag == 0:
st.report_fail("test_case_failed")
else:
st.report_pass("test_case_passed")
def erspan_long_run_func_hooks(request):
# add things at the start every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
yield
# add things at the end every test case
# use 'request.node.name' to compare
# if any thing specific a particular test case
# Deleteing configured ACL classifier at end of each test case
acl_dscp.config_classifier_table(dut=data.dut1,
enable="del",
class_name=data.acl_rule)
if not erspan_pre_config_verify():
st.log(
"######Test case cleanup verification failed. Cleanup existing config and applying pre_config#######"
)
erspan_post_config()
erspan_pre_config()
def test_ft_erspan_action_encapsulation():
"""
Author: Lakshminarayana D ([email protected])
Verify that ERSPAN is working as expected and intended traffic is mirrored to remote interface using various
encapsulation methods:
1. Encapsulation method 0x6558
2. Encapsulation method 0x88ee
Topology:
---------
TG1 ----
DUT1 ---- DUT2 ---- TG3
TG2 ----
"""
encap_list = ['0x88ee', '0x6558']
for encap in encap_list:
st.log("############### Test started for encapusulation method : {} ###############".format(encap))
mirror.create_session(vars.D1, session_name="mirror_" + encap, gre_type=encap,
dscp=data.dscp, ttl=data.ttl, queue=data.queue, src_ip=data.ip_D1T1P1,
dst_ip=data.ip_T1D2P1)
# creation and verification of ACL Rule
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria='--src-ip', class_name=data.acl_rule,
criteria_value=data.src_ip_mask, match_type="fields")
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add',policy_type=data.type,
class_name=data.acl_rule, priority_value=data.priority,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update',policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value="mirror_" + encap)
# TG traffic verification: Needed arguments : capture_values='11.1.1.2, capture_fields='src_ip'
retval = send_traffic(capture_values=[encap.strip('0x')], capture_fields=['gre_protocol'], pkts_per_burst=5,
verify_capture=True)
if not retval[1]:
st.report_fail("traffic_verification_fail", 'capture')
st.report_pass("test_case_passed")
def erspan_pre_config():
"""
Author: Anil Kumar Kacharla<*****@*****.**>
Using this pre config at module level. So, applicable for all test cases which includes in this module.
:return: None
"""
# IP address configuration on DUT-1
for port, ip_addr, in zip(data.port_list_d1, data.ip_list_d1):
ip.config_ip_addr_interface(data.dut1, port, ip_addr, data.subnet_mask)
# IP address configuration on DUT-2
for port, ip_addr in zip(data.port_list_d2, data.ip_list_d2):
ip.config_ip_addr_interface(data.dut2, port, ip_addr, data.subnet_mask)
# Create static route
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D2P1,
data.subnet_mask))
ip.create_static_route(data.dut1, data.ip_D2D1P1, network)
_, network = ip.get_network_addr("{}/{}".format(data.ip_T1D1P1,
data.subnet_mask))
ip.create_static_route(data.dut2, data.ip_D1D2P1, network)
# creation and verification of Monitor session
mirror.create_session(data.dut1,
session_name=data.session_name,
src_ip=data.ip_D1T1P1,
dst_ip=data.ip_T1D2P1,
gre_type=data.gre_type,
dscp=data.dscp,
ttl=data.ttl,
queue=data.queue)
# creation and verification of ACL policy
acl_dscp.config_policy_table(vars.D1,
enable='create',
policy_name=data.acl_table_name,
policy_type=data.type)
acl_dscp.config_service_policy_table(
vars.D1,
policy_kind="bind",
interface_name=vars.D1T1P1,
stage='in',
service_policy_name=data.acl_table_name,
policy_type=data.type)
# creation and verification of ACL classifier
acl_dscp.config_classifier_table(vars.D1,
enable='create',
match_type="fields",
class_name=data.acl_rule)
acl_dscp.config_classifier_table(data.dut1,
enable='yes',
class_criteria=['--src-ip'],
class_name=data.acl_rule,
criteria_value=[data.src_ip_mask],
match_type="fields")
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='add',
class_name=data.acl_rule,
priority_value=data.priority,
description=data.description,
policy_type=data.type)
acl_dscp.config_flow_update_table(data.dut1,
policy_name=data.acl_table_name,
flow='update',
policy_type=data.type,
class_name=data.acl_rule,
priority_option='--mirror-session',
priority_value=data.mirror_action)
def test_ft_erspan_basic_functionality():
"""
Author: Sesha Koilkonda ([email protected])
TC1 FtOpSoSyErspanFn019: Verify that maximum number of mirror sessions are created.
TC2 FtOpSoSyErspanFn015: Verify that multiple mirror sessions can be created and assigned to rules from the same ACL.
TC3 FtOpSoSyErspanFn011: Verify that ERSPAN is working as expected and intended traffic is mirrored to remote interface from multiple interfaces.
Notes from dev: Only 1 Mirror ACL configuration is supported as of now.
maximum Acl rules that can be configured in mirror sesssion(s) is 3.
:return:
"""
ip_add_src, ip_add_dst = data.ip_T1D1P1, data.ip_T1D2P1
max_sessions, data.mask = 4, '32'
tc_fail = 0
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria='--src-ip', class_name=data.acl_rule,
criteria_value="{}/{}".format(ip_add_src, data.mask), match_type="fields")
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type,
class_name=data.acl_rule, priority_value=data.priority,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update',policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value=data.session_name)
#Configure the maximum supported mirror sessions(Session1 alreday created as part of module config.)
for ele in range(1, max_sessions):
_, ip_add_src = ip.increment_ip_addr("{}/{}".format(ip_add_src.split('/')[0], data.mask), "host")
_, ip_add_dst = ip.increment_ip_addr("{}/{}".format(ip_add_dst.split('/')[0], data.mask), "host")
if ele == 2: _, ip_add_src = ip.increment_ip_addr("{}/{}".format(data.ip_D1T1P2, data.mask), "host")
mirror_args = {'session_name': data.session_name + str(ele),'src_ip': ip_add_src.split('/')[0], 'dst_ip': ip_add_dst.split('/')[0],
'dscp':'50', 'ttl':'60', 'gre_type':'0x88ee', 'queue':data.queue}
mirror.create_session(vars.D1, **mirror_args)
if not mirror.verify_session(vars.D1, **mirror_args):
st.log("failed to configure the mirror session: {} ".format(data.session_name + str(ele)))
tc_fail = 1
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule+ str(ele))
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria='--src-ip', match_type="fields",
class_name=data.acl_rule + str(ele),
criteria_value="{}".format(ip_add_src))
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type,
class_name=data.acl_rule+str(ele),priority_value=int(data.priority) + ele,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update',policy_type=data.type,
class_name=data.acl_rule+str(ele), priority_option='--mirror-session',
priority_value=data.session_name + str(ele))
# Traffic validations for the mirror sessions.
ip_add_src, ip_add_dst, tg_src = data.ip_T1D1P1, data.ip_T1D1P2, 'tg_ph_1'
for ele in range(0, max_sessions):
if ele == 2:
_, ip_add_src = ip.increment_ip_addr("{}/{}".format(data.ip_D1T1P2.split('/')[0], data.mask), "host")
_, ip_add_dst = ip.increment_ip_addr("{}/{}".format(data.ip_D1T1P1.split('/')[0], data.mask), "host")
tg_src = 'tg_ph_2'
retval = send_traffic(capture_values=[ip_add_dst], capture_fields=['dst_ip'], ip_src_addr= ip_add_src.split('/')[0],
ip_dst_addr= ip_add_dst.split('/')[0], tg_src_port=tg_src)
if not retval[0]:
st.log('Traffic validation failed for the mirror session combination: source_ip {} , destination_ip {}'.format(ip_add_src,ip_add_dst))
tc_fail = ele
_, ip_add_src = ip.increment_ip_addr("{}/{}".format(ip_add_src.split('/')[0], data.mask), "host")
#Unconfigration part
for ele in range(1, max_sessions):
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='del',
policy_type=data.type, class_name=data.acl_rule + str(ele))
acl_dscp.config_classifier_table(dut=vars.D1, enable="del", class_name=data.acl_rule+str(ele))
mirror.delete_session(vars.D1, data.session_name + str(ele))
if tc_fail == 1:
st.report_fail("mirror_session_fail", "")
elif tc_fail == 2:
st.report_fail("traffic_verification_fail", "packet count")
st.report_pass("test_case_passed")
def test_ft_erspan_action_ethertype_dscp_tcp_flags_l4range():
"""
Author: Lakshminarayana D ([email protected])
Verify that ERSPAN is working as expected and intended traffic with TCP_FLAGS, L4_Range_Ports and dscp from ACL
rule is mirrored to remote interface.
Topology:
---------
TG1 ----
DUT1 ---- DUT2 ---- TG3
TG2 ----
"""
# tcp_flag_info = {'fin': 1, 'syn': 2, 'rst': 4, 'psh': 8, 'ack':16, 'urg': 32}
ip.config_ip_addr_interface(vars.D1, vars.D1T1P1, "2001:1::1", "64", family="ipv6")
ip.config_ip_addr_interface(vars.D1, vars.D1T1P2, "2001:2::1", "64", family="ipv6")
tcp_flag_info = {'fin': 1}
for k, v in tcp_flag_info.items():
kn = 'psh' if k == 'urg' else 'urg'
vn = 8 if v == 32 else 32
proto = 'tcp'
# l4 port values
port_val = {'src_port': 2000, 'dst_port': 3000}
c_fields = [proto + '_src_port', proto + '_dst_port', 'dscp']
# Creating l4_port range parameters to TG stream
tg_arg = {c_fields[0]: port_val['src_port'], c_fields[1]: port_val['dst_port'],
proto + "_src_port_mode": 'incr', proto + "_src_port_count": '10',
proto + "_dst_port_mode": 'incr', proto + "_dst_port_count": '10',
proto + '_src_port_step': '1', proto + '_dst_port_step': '1', 'tcp_' + k + '_flag': 1}
# Creating l4_port range parameters to TG stream to verify negative scenario
tg_argn = {c_fields[0]: port_val['src_port'] + 11, c_fields[1]: port_val['dst_port'] + 11,
'tcp_' + kn + '_flag': 1}
criteria_list = ['--ip-proto', '--dscp', '--tcp-flags', '--src-ip', '--dst-ip','--ether-type', '--src-port',
'--dst-port']
criteria_values = ['6', '8','fin',data.src_ip_mask,data.dst_ip_mask,'0x0800','2000-2010','3000-3010']
acl.create_acl_rule(vars.D1, table_name="L3_IPV6_INGRESS", rule_name="FWD_RULE1", packet_action="FORWARD",
priority=900, ether_type='0x86dd', type="L3V6", ip_protocol="ip")
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria=criteria_list, class_name=data.acl_rule,
criteria_value=criteria_values, match_type="fields")
acl_dscp.config_flow_update_table(vars.D1,policy_name=data.acl_table_name,flow='add',class_name=data.acl_rule,
priority_value=data.priority, description=data.description, policy_type=data.type)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update',policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value=data.mirror_action)
match = [{'class_name': data.acl_rule}]
if not acl_dscp.verify(vars.D1, 'classifier', verify_list=match):
st.report_fail("classifier_opeartion_failed")
# TG traffic verification:
retval = send_traffic(capture_values=[hex(v).lstrip('0x').zfill(2), '0800'],
capture_fields=['tcp_flags', 'ether_type'],
ip_dscp='8', l4_protocol='tcp', **tg_arg)
if not retval[0]:
st.report_fail("traffic_verification_fail", 'packet count')
# TG traffic verification-Negetive check:
retval = send_traffic(capture_values=[hex(vn).lstrip('0x').zfill(2), '86dd'],
capture_fields=['tcp_flags', 'ether_type'],
ip_dscp='56', l4_protocol='tcp', family='ipv6', neg_check=True, **tg_argn)
if retval[0]:
st.report_fail("neg_traffic_verification_fail", 'packet count')
rule_counters=acl.show_acl_counters(vars.D1, acl_table="L3_IPV6_INGRESS", acl_rule="FWD_RULE1", acl_type="ipv6")
if not rule_counters:
st.report_fail("matched_traffic_forward_fail")
if not rule_counters[0]['packetscnt'] or int(rule_counters[0]['packetscnt']) < data.pkts_per_burst:
st.report_fail("matched_traffic_forward_fail")
st.report_pass("test_case_passed")
def test_ft_erspan_action_ip_protocol_ip_addr_l4_ports():
"""
Author: Lakshminarayana D ([email protected])
Verify that ERSPAN is working as expected and intended traffic with configured IP Protocol, SRC_IP, DST_IP,
L4_SRC_PORT and L4_DST_PORT from ACL rule is mirrored to remote interface .
Topology:
---------
TG1 ----
DUT1 ---- DUT2 ---- TG3
TG2 ----
"""
# l4 port protocols
l4_protocol_list = ['tcp']
for proto in l4_protocol_list:
# l4 port values
ip_port_val = {'src_port': 2000, 'dst_port': 3000, 'src_ip': data.ip_T1D1P1, 'dst_ip': data.ip_T1D1P2}
# Used this dict for ACL rule to TG argument mapping
acl_to_tg = {'src_ip': 'ip_dst_addr', 'dst_ip': 'ip_dst_addr'}
# Parsing capture values in hexa decimal format
c_values = [hex(ip_port_val['src_port']).lstrip('0x').zfill(4),
hex(ip_port_val['dst_port']).lstrip('0x').zfill(4), ip_port_val['src_ip'], ip_port_val['dst_ip']]
# Creating capture fileds for capture packet header and offset values formation
c_fields = [proto + '_src_port', proto + '_dst_port', 'src_ip', 'dst_ip']
# Incrementing src and dst ip addresses
_, incr_src = ip.increment_ip_addr("{}/{}".format(ip_port_val['src_ip'], data.mask), "host")
_, incr_dst = ip.increment_ip_addr("{}/{}".format(ip_port_val['dst_ip'], data.mask), "host")
# Parsing capture values in hexa decimal format for negative scenario
cn_values = [hex(ip_port_val['src_port'] + 1).lstrip('0x').zfill(4),
hex(ip_port_val['dst_port'] + 1).lstrip('0x').zfill(4), incr_src.split('/')[0],
incr_dst.split('/')[0]]
# Creating ip addresses and l4_port parameters to form TG stream
tg_arg = {c_fields[0]: ip_port_val['src_port'], c_fields[1]: ip_port_val['dst_port'],
acl_to_tg['src_ip']: ip_port_val['src_ip'], acl_to_tg['dst_ip']: ip_port_val['dst_ip']}
# Creating ip addresses and l4_port parameters to form TG stream to verify negative scenario
tg_argn = {c_fields[0]: ip_port_val['src_port'] + 1, c_fields[1]: ip_port_val['dst_port'] + 1,
acl_to_tg['src_ip']: incr_src.split('/')[0], acl_to_tg['dst_ip']: incr_dst.split('/')[0]}
# creation and verification of ACL Rule
criteria_list = ['--ip-proto', '--src-port', '--dst-port', '--src-ip', '--dst-ip']
criteria_values = ['6', ip_port_val['src_port'], ip_port_val['dst_port'],
"{}/{}".format(ip_port_val['src_ip'], data.mask),
"{}/{}".format(ip_port_val['dst_ip'], data.mask)]
acl_dscp.config_classifier_table(vars.D1, enable='create', match_type="fields", class_name=data.acl_rule)
acl_dscp.config_classifier_table(vars.D1, enable='yes', class_criteria=criteria_list, class_name=data.acl_rule,
criteria_value=criteria_values, match_type="fields")
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='add', policy_type=data.type,
class_name=data.acl_rule, priority_value=data.priority,
description=data.description)
acl_dscp.config_flow_update_table(vars.D1, policy_name=data.acl_table_name, flow='update',policy_type=data.type,
class_name=data.acl_rule, priority_option='--mirror-session',
priority_value=data.mirror_action)
# TG traffic verification:
retval = send_traffic(capture_values=c_values, capture_fields=c_fields, l4_protocol=proto, **tg_arg)
if not retval[0]:
st.report_fail("traffic_verification_fail", 'packet count')
# TG traffic verification-Negetive check:
retval = send_traffic(capture_values=cn_values, capture_fields=c_fields, l4_protocol=proto, neg_check=True,
**tg_argn)
if retval[0]:
st.report_fail("neg_traffic_verification_fail", 'packet count')
st.report_pass("test_case_passed")
