def config_port_qos_map(dut, obj_name, interface, **kwargs):
cli_type = st.get_ui_type(dut, **kwargs)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
if not obj_name or not interface:
st.log(
"Please provide obj_name like 'AZURE' and interface like 'Ethernet0,Ethernet1'"
)
return False
else:
cos_specific_dict = {
"tc_to_queue_map": "[TC_TO_QUEUE_MAP|" + obj_name + "]",
"dscp_to_tc_map": "[DSCP_TO_TC_MAP|" + obj_name + "]"
}
temp_data[interface] = cos_specific_dict
final_data['PORT_QOS_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
intf_data = get_interface_number_from_name(interface)
commands.append('interface {} {}'.format(intf_data['type'],
intf_data['number']))
commands.append('qos-map tc-queue {}'.format(obj_name))
commands.append('qos-map dscp-tc {}'.format(obj_name))
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
rest_urls = st.get_datastore(dut, 'rest_urls')
url = rest_urls['port_qos_map_config'].format(interface)
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"dscp-to-forwarding-group": obj_name,
"forwarding-group-to-queue": obj_name
}
}
}
if not config_rest(dut,
rest_url=url,
http_method=cli_type,
json_data=port_qos_map_data):
st.error("Failed configure PORT_QOS_MAP")
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def add_ntp_servers(dut, iplist=[], cli_type=''):
"""
:param dut:
:param iplist:
:return:
"""
cli_type = st.get_ui_type(dut, cli_type=cli_type)
st.log("add ntp servers")
final_data = {}
temp_data = {}
if iplist:
for ip in iplist:
temp_data[ip] = {}
else:
st.log("please provide atleast 1 server to configure")
return False
if cli_type == "click":
final_data['NTP_SERVER'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == "klish":
for ip in iplist:
commands = "ntp server {}".format(ip)
st.config(dut, commands, type=cli_type)
elif cli_type in ['rest-patch', 'rest-put']:
for ip in iplist:
data={
"openconfig-system:servers": {
"server": [
{
"address": str(ip),
"config": {
"address": str(ip)
}
}
]
}
}
rest_urls = st.get_datastore(dut, "rest_urls")
url1 = rest_urls['config_ntp_server'].format(ip)
if not config_rest(dut, http_method=cli_type, rest_url=url1, json_data=data):
st.error("Failed to configure ntp {} server".format(ip))
return False
else:
st.log("UNSUPPORTED CLI TYPE -- {}".format(cli_type))
return False
st.log("Regenerate the ntp-config")
command = "systemctl restart ntp-config"
st.config(dut, command)
return True
def config_dscp_to_tc_map(dut,obj_name,dscp_to_tc_map_dict):
st.log(sys._getframe( ).f_code.co_name.replace('_',' '))
final_data = dict()
temp_data = dict()
if not dscp_to_tc_map_dict or not obj_name:
st.log("Please provide dscp value to traffic priority value map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'")
return False
else:
temp_data[obj_name] = dscp_to_tc_map_dict
final_data['DSCP_TO_TC_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
return True
def config_tc_to_pg_map(dut,obj_name,tc_to_pg_map_dict):
st.log(sys._getframe( ).f_code.co_name.replace('_',' '))
final_data = dict()
temp_data = dict()
if not tc_to_pg_map_dict or not obj_name:
st.log("Please provide traffic class to priority group map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'")
return False
else:
temp_data[obj_name] = tc_to_pg_map_dict
final_data['TC_TO_PRIORITY_GROUP_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
return True
def config_port_qos_map(dut,obj_name,interface):
st.log(sys._getframe( ).f_code.co_name.replace('_',' '))
final_data = dict()
temp_data = dict()
if not obj_name or not interface:
st.log("Please provide obj_name like 'AZURE' and interface like 'Ethernet0,Ethernet1'")
return False
else:
cos_specific_dict = {"tc_to_queue_map": "[TC_TO_QUEUE_MAP|" + obj_name + "]", "dscp_to_tc_map": "[DSCP_TO_TC_MAP|" + obj_name + "]" }
temp_data[interface] = cos_specific_dict
final_data['PORT_QOS_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
return True
def bind_qos_map_port(dut, map_name, obj_name, interface):
'''
:param dut: device to be configured
:type dut: string
:param map_name: qos map name for example dscp_to_tc_map, tc_to_queue_map
:type map_name: string
:param obj_name: object name for example AZURE
:type obj_name: string
:param interface: interface to be associated for example Ethernet1
:type interface: string
:return: True/False True - Success ; False - Failure
usage:
bind_qos_map_port(dut1, "tc_to_queue_map", "Azure", "Ethernet0")
bind_qos_map_port(dut1, "dscp_to_tc_map", "Azure", "Ethernet2")
bind_qos_map_port(dut1, "tc_to_pg_map", "Azure", "Ethernet72")
Created by: Julius <[email protected]
'''
final_data, temp_data = dict(), dict()
data = { map_name : "[" + map_name.upper() + "|" + obj_name + "]"}
temp_data[interface] = data
final_data['PORT_QOS_MAP'] = temp_data
data_json = json.dumps(final_data)
return st.apply_json(dut, data_json)
def write_config_db(dut, data):
"""
To Write config to config DB
Author : Prudvi Mangadu ([email protected])
:param dut:
:param data: dictionary/ JSON format
:return:
"""
st.log("JSON Data Provided:")
st.log(pprint.pformat(data, width=2))
return st.apply_json(dut, json.dumps(data))
def config_syslog_server(dut, ipaddress_list):
"""
Configure syslog servers.
Author: Prudvi Mangadu ([email protected])
:param dut:
:param ipaddress_list:
:return:
"""
ipaddress_li = list(ipaddress_list) if isinstance(
ipaddress_list, list) else [ipaddress_list]
st.log("Adding syslog server(s)")
temp_local_data = {}
syslog_local_final = {}
for each_address in ipaddress_li:
temp_local_data[each_address] = {}
syslog_local_final['SYSLOG_SERVER'] = temp_local_data
syslog_local_final_json = json.dumps(syslog_local_final)
st.apply_json(dut, syslog_local_final_json)
return True
def set_lldp_local_parameters(dut, name, **kwargs):
"""
Set LLDP Local parameters
Author: Prudvi Mangadu ([email protected])
:param dut:
:param name:
:param mgmt_addr:
:param hwsku:
:param lo_addr:
:param local_port:
:param local_port:
:param type:
:param port:
:return:
"""
st.log("Adding local lldp data")
temp_local_data = {}
lldp_local_final = {}
if not kwargs:
st.error("SET LLDP Local parameters failed because of invalid data.")
return False
if 'mgmt_addr' in kwargs:
temp_local_data['mgmt_addr'] = kwargs['mgmt_addr']
if 'hwsku' in kwargs:
temp_local_data['hwsku'] = kwargs['hwsku']
if 'lo_addr' in kwargs:
temp_local_data['lo_addr'] = kwargs['lo_addr']
if 'local_port' in kwargs:
temp_local_data['local_port'] = kwargs['local_port']
if 'type' in kwargs:
temp_local_data['type'] = kwargs['type']
if 'port' in kwargs:
temp_local_data['port'] = kwargs['port']
lldp_local_final['DEVICE_NEIGHBOR'] = {name: temp_local_data}
lldp_local_final_json = json.dumps(lldp_local_final)
st.apply_json(dut, lldp_local_final_json)
return True
def add_ntp_servers(dut, iplist=[]):
"""
:param dut:
:param iplist:
:return:
"""
st.log("add ntp servers")
final_data = {}
temp_data = {}
if iplist:
for ip in iplist:
temp_data[ip] = {}
else:
st.log("please provide atleast 1 server to configure")
return False
final_data['NTP_SERVER'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
st.log("Regenerate the ntp-config")
command = "systemctl restart ntp-config"
st.config(dut, command)
return True
def create_qos_json(dut, block_name, sub_block, dict_input):
'''
:param dut: device to be configured
:type dut: string
:param block_name: name of the field in json, for eg: dscp_to_tc_map, tc_to_queue_map, wred_profile etc
:type block_name: string
:param sub_block: sub field name, for eg: AZURE, AZURE_LOSSLESS etc
:type sub_block: string
:param dict_input: input values in dictionary
:type dict_input: string
:return: True/False True - Success ; False - Failure
usage:
create_qos_json(dut1, "tc_to_queue_map", "Azure", {"wred_green_enable" : "true"})
Created by: Julius <[email protected]
'''
final_data, temp_data = dict(), dict()
temp_data[sub_block] = dict_input
final_data[block_name.upper()] = temp_data
final_data = json.dumps(final_data)
return st.apply_json(dut, final_data)
def config_dot1p_to_tc_map(dut, obj_name, dot1p_to_tc_map_dict, **kwargs):
"""
Author: Jagadish Chatrasi ([email protected])
To map the dot1p to tc
:param dut:
:type dut:
:param obj_name:
:type obj_name:
:param dot1p_to_tc_map_dict:
:type dict:
"""
cli_type = st.get_ui_type(dut, **kwargs)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
dot1p_to_tc_map_dict = get_non_range_map_data_from_range_map_data(
dot1p_to_tc_map_dict)
if not dot1p_to_tc_map_dict or not obj_name:
st.log(
"Please provide dot1p value to traffic class value map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'"
)
return False
else:
temp_data[obj_name] = dot1p_to_tc_map_dict
final_data['DOT1P_TO_TC_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
commands.append('qos map dot1p-tc {}'.format(obj_name))
for dot1p, tc in dot1p_to_tc_map_dict.items():
commands.append('dot1p {} traffic-class {}'.format(dot1p, tc))
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
cli_type = 'rest-patch'
rest_urls = st.get_datastore(dut, 'rest_urls')
url = rest_urls['dot1p_tc_map_config'].format(obj_name)
dot1p_to_tc_map_dict = get_non_range_map_data_from_range_map_data(
dot1p_to_tc_map_dict)
maps_data = [{
"dot1p": int(dot1p),
"config": {
"dot1p": int(dot1p),
"fwd-group": str(tc)
}
} for dot1p, tc in dot1p_to_tc_map_dict.items()]
dot1p_tc_map_data = {
"openconfig-qos-maps-ext:dot1p-map": [{
"name": obj_name,
"config": {
"name": obj_name
},
"dot1p-map-entries": {
"dot1p-map-entry": maps_data
}
}]
}
if not config_rest(dut,
rest_url=url,
http_method=cli_type,
json_data=dot1p_tc_map_data):
st.error("Failed to map DOT1P to TC with data: {}".format(
dot1p_to_tc_map_dict))
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def config_pfc_priority_to_queue_map(dut, obj_name,
pfc_priority_to_queue_map_dict, **kwargs):
"""
Author: Jagadish Chatrasi ([email protected])
To map the PFC priority to queue
:param dut:
:type dut:
:param obj_name:
:type obj_name:
:param pfc_priority_to_queue_map_dict:
:type dict:
"""
cli_type = st.get_ui_type(dut, **kwargs)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
pfc_priority_to_queue_map_dict = get_non_range_map_data_from_range_map_data(
pfc_priority_to_queue_map_dict)
if not pfc_priority_to_queue_map_dict or not obj_name:
st.log(
"Please provide pfc priority to queue map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'"
)
return False
else:
temp_data[obj_name] = pfc_priority_to_queue_map_dict
final_data['MAP_PFC_PRIORITY_TO_QUEUE'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
commands.append('qos map pfc-priority-queue {}'.format(obj_name))
for pfc_priority, queue in pfc_priority_to_queue_map_dict.items():
commands.append('pfc-priority {} queue {}'.format(
pfc_priority, queue))
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
cli_type = 'rest-patch'
rest_urls = st.get_datastore(dut, 'rest_urls')
url = rest_urls['pfc_priority_queue_map_config']
pfc_priority_to_queue_map_dict = get_non_range_map_data_from_range_map_data(
pfc_priority_to_queue_map_dict)
maps_data = [{
"dot1p": int(dot1p),
"config": {
"dot1p": int(dot1p),
"output-queue-index": int(queue)
}
} for dot1p, queue in pfc_priority_to_queue_map_dict.items()]
pfc_priority_queue_map_data = {
"openconfig-qos-maps-ext:pfc-priority-queue-map": [{
"name": obj_name,
"config": {
"name": obj_name
},
"pfc-priority-queue-map-entries": {
"pfc-priority-queue-map-entry": maps_data
}
}]
}
if not config_rest(dut,
rest_url=url,
http_method=cli_type,
json_data=pfc_priority_queue_map_data):
st.error(
"Failed to map PFC_PRIORITY to QUEUE with data: {}".format(
pfc_priority_to_queue_map_dict))
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def config_port_qos_map_all(dut, qos_maps, cli_type=''):
"""
To configure port qos map for all types of mappings
Author: Jagadish Chatrasi ([email protected])
:param dut:
:type dut:
:param qos_maps:
:type qos_maps:
:param cli_type:
:type cli_type:
"""
qos_maps = make_list(qos_maps)
cli_type = st.get_ui_type(dut, cli_type=cli_type)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
for qos_map in qos_maps:
if qos_map['port'] not in temp_data:
temp_data[qos_map['port']] = {}
if qos_map['map'] == 'dot1p_to_tc_map':
temp_data[qos_map['port']].update(
dot1p_to_tc_map="[DOT1P_TO_TC_MAP|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'dscp_to_tc_map':
temp_data[qos_map['port']].update(
dscp_to_tc_map="[DSCP_TO_TC_MAP|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'pfc_to_queue_map':
temp_data[qos_map['port']].update(
pfc_to_queue_map="[MAP_PFC_PRIORITY_TO_QUEUE|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_dot1p_map':
temp_data[qos_map['port']].update(
tc_to_dot1p_map="[TC_TO_DOT1P_MAP|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_dscp_map':
temp_data[qos_map['port']].update(
tc_to_dscp_map="[TC_TO_DSCP_MAP|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_pg_map':
temp_data[qos_map['port']].update(
tc_to_pg_map="[TC_TO_PRIORITY_GROUP_MAP|{}]".format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_queue_map':
temp_data[qos_map['port']].update(
tc_to_queue_map="[TC_TO_QUEUE_MAP|{}]".format(
qos_map['obj_name']))
else:
st.error('Invalid map: {}'.format(qos_map['map']))
return False
final_data['PORT_QOS_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
for qos_map in qos_maps:
intf_data = get_interface_number_from_name(qos_map['port'])
commands.append('interface {} {}'.format(intf_data['type'],
intf_data['number']))
if qos_map['map'] == 'dot1p_to_tc_map':
commands.append('qos-map dot1p-tc {}'.format(
qos_map['obj_name']))
elif qos_map['map'] == 'dscp_to_tc_map':
commands.append('qos-map dscp-tc {}'.format(
qos_map['obj_name']))
elif qos_map['map'] == 'pfc_to_queue_map':
commands.append('qos-map pfc-priority-queue {}'.format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_dot1p_map':
commands.append('qos-map tc-dot1p {}'.format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_dscp_map':
commands.append('qos-map tc-dscp {}'.format(
qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_pg_map':
commands.append('qos-map tc-pg {}'.format(qos_map['obj_name']))
elif qos_map['map'] == 'tc_to_queue_map':
commands.append('qos-map tc-queue {}'.format(
qos_map['obj_name']))
else:
st.error('Invalid map: {}'.format(qos_map['map']))
return False
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
rest_urls = st.get_datastore(dut, 'rest_urls')
for qos_map in qos_maps:
url = rest_urls['port_qos_map_config'].format(qos_map['port'])
if qos_map['map'] == 'dot1p_to_tc_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"dot1p-to-forwarding-group": qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'dscp_to_tc_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"dscp-to-forwarding-group": qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'pfc_to_queue_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"pfc-priority-to-queue": qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'tc_to_dot1p_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"forwarding-group-to-dot1p": qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'tc_to_dscp_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"forwarding-group-to-dscp": qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'tc_to_pg_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"forwarding-group-to-priority-group":
qos_map['obj_name']
}
}
}
elif qos_map['map'] == 'tc_to_queue_map':
port_qos_map_data = {
"openconfig-qos-maps-ext:interface-maps": {
"config": {
"forwarding-group-to-queue": qos_map['obj_name']
}
}
}
else:
st.error('Invalid map: {}'.format(qos_map['map']))
return False
if not config_rest(dut,
rest_url=url,
http_method=cli_type,
json_data=port_qos_map_data):
st.error("Failed configure PORT_QOS_MAP")
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def config_tc_to_dscp_map(dut, obj_name, tc_to_dscp_map_dict, **kwargs):
"""
Author: Jagadish Chatrasi ([email protected])
To map the tc to dscp
:param dut:
:type dut:
:param obj_name:
:type obj_name:
:param tc_to_dscp_map_dict:
:type dict:
"""
cli_type = st.get_ui_type(dut, **kwargs)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
tc_to_dscp_map_dict = get_non_range_map_data_from_range_map_data(
tc_to_dscp_map_dict)
if not tc_to_dscp_map_dict or not obj_name:
st.log(
"Please provide traffic class to dscp map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'"
)
return False
else:
temp_data[obj_name] = tc_to_dscp_map_dict
final_data['TC_TO_DSCP_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
commands.append('qos map tc-dscp {}'.format(obj_name))
for tc, dscp in tc_to_dscp_map_dict.items():
commands.append('traffic-class {} dscp {}'.format(tc, dscp))
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
cli_type = 'rest-patch'
rest_urls = st.get_datastore(dut, 'rest_urls')
url = rest_urls['tc_dscp_map_config'].format(obj_name)
tc_to_dscp_map_dict = get_non_range_map_data_from_range_map_data(
tc_to_dscp_map_dict)
maps_data = [{
"fwd-group": str(tc),
"config": {
"fwd-group": str(tc),
"dscp": int(dscp)
}
} for tc, dscp in tc_to_dscp_map_dict.items()]
tc_dscp_map_data = {
"openconfig-qos-maps-ext:forwarding-group-dscp-map": [{
"name": obj_name,
"config": {
"name": obj_name
},
"forwarding-group-dscp-map-entries": {
"forwarding-group-dscp-map-entry": maps_data
}
}]
}
if not config_rest(dut,
rest_url=url,
http_method=cli_type,
json_data=tc_dscp_map_data):
st.error("Failed to map TC to DSCP with data: {}".format(
tc_to_dscp_map_dict))
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def create_copp_json(dut, block_name, dict_input):
temp_data = {block_name: dict_input, "OP": "SET"}
temp_data = [temp_data]
final_data = json.dumps(temp_data)
return st.apply_json(dut, final_data)
def config_tc_to_pg_map(dut, obj_name, tc_to_pg_map_dict, **kwargs):
cli_type = st.get_ui_type(dut, **kwargs)
if cli_type == 'click':
final_data = dict()
temp_data = dict()
tc_to_pg_map_dict = get_non_range_map_data_from_range_map_data(
tc_to_pg_map_dict)
if not tc_to_pg_map_dict or not obj_name:
st.log(
"Please provide traffic class to priority group map dict. For example - {'0':'0', '1':'1', ...} and Object name like 'AZURE'"
)
return False
else:
temp_data[obj_name] = tc_to_pg_map_dict
final_data['TC_TO_PRIORITY_GROUP_MAP'] = temp_data
final_data = json.dumps(final_data)
st.apply_json(dut, final_data)
elif cli_type == 'klish':
commands = list()
commands.append('qos map tc-pg {}'.format(obj_name))
for tc, pg in tc_to_pg_map_dict.items():
commands.append('traffic-class {} priority-group {}'.format(
tc, pg))
commands.append('exit')
response = st.config(dut, commands, type=cli_type)
if any(error in response.lower() for error in errors_list):
st.error("The response is: {}".format(response))
return False
elif cli_type in ['rest-patch', 'rest-put']:
cli_type = 'rest-patch'
rest_urls = st.get_datastore(dut, 'rest_urls')
url = rest_urls['tc_pg_map_config']
tc_to_pg_map_dict = get_non_range_map_data_from_range_map_data(
tc_to_pg_map_dict)
maps_data = [{
"fwd-group": str(tc),
"config": {
"fwd-group": str(tc),
"priority-group-index": int(pg)
}
} for tc, pg in tc_to_pg_map_dict.items()]
tc_pg_map_data = {
"openconfig-qos-maps-ext:forwarding-group-priority-group-map": [{
"name":
obj_name,
"config": {
"name": obj_name
},
"forwarding-group-priority-group-map-entries": {
"forwarding-group-priority-group-map-entry": maps_data
}
}]
}
if not config_rest(
dut, rest_url=url, http_method=cli_type,
json_data=tc_pg_map_data):
st.error("Failed to map TC to PG with data: {}".format(
tc_to_pg_map_dict))
return False
else:
st.error("Unsupported CLI Type: {}".format(cli_type))
return False
return True
def create_session_table(dut, **kwargs):
"""
Creating monitor session via config_db.json file
Author: Lakshminarayana D ([email protected])
:param dut:
:param kwargs: Needed arguments to build mirror session json data
:return:
"""
mirror_data = kwargs
if 'session_name' not in mirror_data:
st.error("Session name not provided ...")
return False
if 'src_ip' not in mirror_data:
st.error("Source IP not provided ...")
return False
if 'dst_ip' not in mirror_data:
st.error("Destination IP not provided ...")
return False
if 'dscp' not in mirror_data:
st.error("dscp not provided ...")
return False
if 'ttl' not in mirror_data:
st.error("ttl not provided ...")
return False
# gre_type and queue is optional arguments to create mirror session.
# Sample config_db.json output
"""
"MIRROR_SESSION": {
"mirr": {
"dscp": "20",
"dst_ip": "2.2.2.2",
"gre_type": "0x88ee",
"queue": "0",
"src_ip": "1.1.1.1",
"ttl": "100"
}
},
"""
mirror_table = dict()
mirror_table_data = dict()
mirror_table_data[mirror_data["session_name"]] = dict()
mirror_table_data[
mirror_data["session_name"]]["src_ip"] = mirror_data["src_ip"]
mirror_table_data[
mirror_data["session_name"]]["dst_ip"] = mirror_data["dst_ip"]
mirror_table_data[
mirror_data["session_name"]]["dscp"] = mirror_data["dscp"]
mirror_table_data[mirror_data["session_name"]]["ttl"] = mirror_data["ttl"]
mirror_table_data[mirror_data["session_name"]]["gre_type"] = mirror_data[
"gre_type"] if 'gre_type' in mirror_data else "0x88ee"
mirror_table_data[mirror_data["session_name"]][
"queue"] = mirror_data["queue"] if 'queue' in mirror_data else "0"
mirror_table["MIRROR_SESSION"] = mirror_table_data
mirror_table = json.dumps(mirror_table)
st.apply_json(dut, mirror_table)
if not verify_session(dut, **kwargs):
return False
return True
