def init_asic_evpn_map_info(self):
if not (self.encap_mappers or self.decap_mappers):
self.ret_temp["ASIC_DB"]["tables_not_found"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP")
return None
for key in self.encap_mappers:
if key in self.asic_tunnel_map_cache:
ret = self.asic_tunnel_map_cache[key]
else:
req = MatchRequest(
db="ASIC_DB",
table="ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP",
key_pattern=key,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.asic_tunnel_map_cache[key] = ret
self.add_to_ret_template(req.table, req.db, ret["keys"],
ret["error"])
for key in self.decap_mappers:
if key in self.asic_tunnel_map_cache:
ret = self.asic_tunnel_map_cache[key]
else:
req = MatchRequest(
db="ASIC_DB",
table="ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP",
key_pattern=key,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.asic_tunnel_map_cache[key] = ret
self.add_to_ret_template(req.table, req.db, ret["keys"],
ret["error"])
def init_asic_vxlan_tunnel_map_entry_info(self):
if not self.vlan:
self.ret_temp["ASIC_DB"]["tables_not_found"].append(
"ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY")
return None
req = MatchRequest(db="ASIC_DB",
table="ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY",
field="SAI_TUNNEL_MAP_ENTRY_ATTR_VLAN_ID_VALUE",
value=self.vlan,
ns=self.ns,
return_fields=[
"SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP_TYPE",
"SAI_TUNNEL_MAP_ENTRY_ATTR_VNI_ID_KEY",
"SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP"
])
ret = self.match_engine.fetch(req)
ret["keys"] = [
x for x in ret["keys"] if ret["return_values"][x]
["SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP_TYPE"] ==
"SAI_TUNNEL_MAP_TYPE_VNI_TO_VLAN_ID"
]
ret["keys"] = [
x for x in ret["keys"] if ret["return_values"][x]
["SAI_TUNNEL_MAP_ENTRY_ATTR_VNI_ID_KEY"] == self.vni
]
if ret["keys"]:
self.tunnel_map_obj = ret["return_values"][
ret["keys"][0]]["SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP"]
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def test_missing_field(self):
rv = {
"COPP_GROUP|queue4_group2": {
"trap_action": "copy",
"trap_priority": "4",
"queue": "4",
"meter_type": "packets",
"mode": "sr_tcm",
"cir": "600",
"cbs": "600",
"red_action": "drop"
}
}
template = {"error": "", "keys": [rv], "return_values": {}}
m_engine = MatchEngine()
m_engine.fetch = MagicMock(return_value=template)
m_engine_optim = MatchRequestOptimizer(m_engine)
req = MatchRequest(db="CONFIG_DB",
table="COPP_GROUP",
key_pattern="queue4*",
field="red_action",
value="drop",
return_fields=["whatever"])
ret = m_engine_optim.fetch(req)
assert ret["error"] == ""
assert len(ret["keys"]) == 1
assert "COPP_GROUP|queue4_group2" in ret["keys"]
# missing filed should not cause an excpetion in the optimizer
assert "whatever" in ret["return_values"]["COPP_GROUP|queue4_group2"]
assert not ret["return_values"]["COPP_GROUP|queue4_group2"]["whatever"]
def init_asic_port_info(self, asic_port_obj_id):
if not asic_port_obj_id:
self.ret_temp["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_PORT")
return None
req = MatchRequest(db="ASIC_DB", table="ASIC_STATE:SAI_OBJECT_TYPE_PORT", key_pattern=asic_port_obj_id, ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def get_all_args(self, ns):
all_trap_ids = set()
req = MatchRequest(file=Copp.CONFIG_FILE,
table=CFG_COPP_TRAP_TABLE_NAME,
return_fields=["trap_ids"],
ns=ns)
ret = self.match_engine.fetch(req)
all_trap_ids.update(self.fetch_all_trap_ids(ret))
req = MatchRequest(db="CONFIG_DB",
table=CFG_COPP_TRAP_TABLE_NAME,
return_fields=["trap_ids"],
ns=ns)
ret = self.match_engine.fetch(req)
all_trap_ids.update(self.fetch_all_trap_ids(ret))
return list(all_trap_ids)
def init_vlan_appl_info(self, vlan_name):
req = MatchRequest(db="APPL_DB",
table="VLAN_TABLE",
key_pattern=vlan_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def get_port_acl_binding(db_wrap, port, ns):
"""
Verify if the port is not bound to any ACL Table
Args:
db_wrap: utilities_common.Db() object
port: Iface name
ns: namespace
Returns:
list: ACL_TABLE names if found,
otherwise empty
"""
ACL = "ACL_TABLE" # Table to look for port bindings
if not isinstance(db_wrap, Db):
raise Exception("db_wrap object is not of type utilities_common.Db")
conn_pool = ConnectionPool()
conn_pool.fill(ns, db_wrap.db_clients[ns], db_wrap.db_list)
m_engine = MatchEngine(conn_pool)
req = MatchRequest(db="CONFIG_DB",
table=ACL,
key_pattern="*",
field="ports@",
value=port,
ns=ns,
match_entire_list=False)
ret = m_engine.fetch(req)
acl_tables, _ = get_matched_keys(ret)
return acl_tables
def init_port_config_info(self, port_name):
req = MatchRequest(db="CONFIG_DB",
table="PORT",
key_pattern=port_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def __get_asic_hostif_trap_group_obj(self, trap_group_obj):
if not trap_group_obj:
self.ret_temp["ASIC_DB"]["tables_not_found"].append(
ASIC_TRAP_GROUP_OBJ)
return "", ""
req = MatchRequest(db="ASIC_DB",
table=ASIC_TRAP_GROUP_OBJ,
key_pattern=trap_group_obj,
ns=self.ns,
return_fields=[
"SAI_HOSTIF_TRAP_GROUP_ATTR_QUEUE",
"SAI_HOSTIF_TRAP_GROUP_ATTR_POLICER"
])
ret = self.match_engine.fetch(req)
if not ret["error"] and len(ret["keys"]) > 0:
trap_group_asic_key = ret["keys"][0]
self.ret_temp["ASIC_DB"]["keys"].append(trap_group_asic_key)
SAI_QUEUE_INDEX = ret["return_values"][trap_group_asic_key][
"SAI_HOSTIF_TRAP_GROUP_ATTR_QUEUE"]
SAI_POLICER_OBJ = ret["return_values"][trap_group_asic_key][
"SAI_HOSTIF_TRAP_GROUP_ATTR_POLICER"]
return SAI_QUEUE_INDEX, SAI_POLICER_OBJ
else:
self.ret_temp["ASIC_DB"]["tables_not_found"].append(
ASIC_TRAP_GROUP_OBJ)
return "", ""
def init_state_fdb_info(self, fdb_name):
req = MatchRequest(db="STATE_DB",
table="FDB_TABLE",
key_pattern=fdb_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def test_file_source_with_not_only_return_keys(self, match_engine):
file = os.path.join(dump_test_input, "copp_cfg.json")
req = MatchRequest(file=file,
table="COPP_GROUP",
key_pattern="queue4*",
field="red_action",
value="drop",
just_keys=False)
ret = match_engine.fetch(req)
assert ret["error"] == ""
assert len(ret["keys"]) == 1
recv_dict = ret["keys"][0]
exp_dict = {
"COPP_GROUP|queue4_group2": {
"trap_action": "copy",
"trap_priority": "4",
"queue": "4",
"meter_type": "packets",
"mode": "sr_tcm",
"cir": "600",
"cbs": "600",
"red_action": "drop"
}
}
ddiff = DeepDiff(exp_dict, recv_dict)
assert not ddiff, ddiff
def get_all_args(self, ns=""):
req = MatchRequest(db="STATE_DB",
table="FDB_TABLE",
key_pattern="*",
ns=ns)
ret = self.match_engine.fetch(req)
fdb_entries = ret["keys"]
return [key.split("|")[-1] for key in fdb_entries]
def get_all_args(self, ns=""):
req = MatchRequest(db="CONFIG_DB",
table="VLAN",
key_pattern="*",
ns=ns)
ret = self.match_engine.fetch(req)
all_vlans = ret["keys"]
return [key.split("|")[-1] for key in all_vlans]
def get_all_args(self, ns=""):
req = MatchRequest(db="APPL_DB",
table="VXLAN_REMOTE_VNI_TABLE",
key_pattern="*",
ns=ns)
ret = self.match_engine.fetch(req)
evpns = ret["keys"]
return [key.split(":", 1)[-1] for key in evpns]
def test_for_no_match(self, match_engine):
req = MatchRequest(db="ASIC_DB",
table="ASIC_STATE:SAI_OBJECT_TYPE_SWITCH",
field="SAI_SWITCH_ATTR_SRC_MAC_ADDRESS",
value="DE:AD:EE:EE:EE")
ret = match_engine.fetch(req)
assert ret["error"] == EXCEP_DICT["NO_ENTRIES"]
assert len(ret["keys"]) == 0
def test_invalid_combination(self, match_engine):
req = MatchRequest(db="CONFIG_DB",
table="COPP_TRAP",
key_pattern="*",
field="trap_ids",
value="sample_packet")
ret = match_engine.fetch(req)
assert ret["error"] == EXCEP_DICT["NO_MATCHES"]
def init_lag_asic_info(self, lag_type_objs_asic):
if len(lag_type_objs_asic) == 0:
self.ret_temp["ASIC_DB"]["tables_not_found"].extend(["ASIC_STATE:SAI_OBJECT_TYPE_LAG"])
return
for lag_asic_obj in lag_type_objs_asic:
req = MatchRequest(db="ASIC_DB", table="ASIC_STATE:SAI_OBJECT_TYPE_LAG", key_pattern=lag_asic_obj, ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def init_asic_vxlan_tunnel_term_info(self):
if not self.tunnel_obj:
self.ret_temp["ASIC_DB"]["tables_not_found"].append("ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY")
return None
req = MatchRequest(db="ASIC_DB", table="ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY",
field="SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_ACTION_TUNNEL_ID", value=self.tunnel_obj, ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def init_vlan_member_config_info(self, vlan_name, member_name):
req = MatchRequest(db="CONFIG_DB", table="VLAN_MEMBER", key_pattern=vlan_name+'|'+member_name+"*", ns=self.ns)
ret = self.match_engine.fetch(req)
if not ret["error"] and len(ret["keys"]) != 0:
for mem in ret["keys"]:
self.ret_temp[req.db]["keys"].append(mem)
else:
self.ret_temp[req.db]["tables_not_found"].append(req.table)
def init_state_evpn_info(self, evpn_name):
state_key = "EVPN_" + self.remote_ip
req = MatchRequest(db="STATE_DB",
table="VXLAN_TUNNEL_TABLE",
key_pattern=state_key,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def add_intf_keys(self, db_name, table_name):
# Fetch Interface Keys
req = MatchRequest(db=db_name,
table=table_name,
key_pattern=self.intf_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
# Fetch IP & Interface Related keys
req = MatchRequest(db=db_name,
table=table_name,
key_pattern=self.intf_name + self.get_sep(db_name) +
"*",
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"],
False)
def init_lag_state_info(self):
req = MatchRequest(db="STATE_DB",
table="LAG_TABLE",
key_pattern=self.lag_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
return self.add_to_ret_template(req.table, req.db, ret["keys"],
ret["error"])
def test_valid_match_request(self):
try:
req = MatchRequest(db="APPL_DB",
table="PORT_TABLE",
field="lanes",
value="202")
except Exception as e:
assert False, "Exception Raised for a Valid MatchRequest" + str(e)
def get_all_args(self, ns=""):
req = MatchRequest(db="CONFIG_DB",
table="VXLAN_TUNNEL_MAP",
key_pattern="*",
ns=ns)
ret = self.match_engine.fetch(req)
vxlan_tunnel_maps = ret["keys"]
return [key.split("|", 1)[-1] for key in vxlan_tunnel_maps]
def init_lag_config_info(self):
req = MatchRequest(db="CONFIG_DB",
table="PORTCHANNEL",
key_pattern=self.lag_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
return self.add_to_ret_template(req.table, req.db, ret["keys"],
ret["error"])
def init_vxlan_tunnel_map_appl_info(self, vxlan_tunnel_map_name):
app_vxlan_tunnel_map_name = vxlan_tunnel_map_name.replace('|', ':')
req = MatchRequest(db="APPL_DB",
table="VXLAN_TUNNEL_MAP_TABLE",
key_pattern=app_vxlan_tunnel_map_name,
ns=self.ns)
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
def init_route_appl_info(self):
req = MatchRequest(db="APPL_DB", table="ROUTE_TABLE", key_pattern=self.dest_net,
ns=self.ns, return_fields=["nexthop_group"])
ret = self.match_engine.fetch(req)
self.add_to_ret_template(req.table, req.db, ret["keys"], ret["error"])
if ret["keys"]:
return ret["return_values"].get(ret["keys"][0], {}).get("nexthop_group", "")
return ""
def get_all_args(self, ns=""):
req = MatchRequest(db="CONFIG_DB",
table="ACL_TABLE",
key_pattern="*",
ns=ns)
ret = self.match_engine.fetch(req)
acl_tables = ret["keys"]
return [key.split(CFG_DB_SEPARATOR)[-1] for key in acl_tables]
def init_asic_next_hop_info(self, oid, add_to_tables_not_found=True):
ret = {}
if oid:
req = MatchRequest(db="ASIC_DB", table=NH, key_pattern=oid, ns=self.rt.ns,
return_fields=["SAI_NEXT_HOP_ATTR_ROUTER_INTERFACE_ID"])
ret = self.rt.nhgrp_match_engine.fetch(req)
keys = self.rt.add_to_ret_template(NH, "ASIC_DB", ret.get("keys", []), ret.get("error", ""), add_to_tables_not_found)
nh_key = keys[0] if keys else ""
return ret.get("return_values", {}).get(nh_key, {}).get("SAI_NEXT_HOP_ATTR_ROUTER_INTERFACE_ID", "")
def test_field_value_no_match(self, match_engine):
req = MatchRequest(db="STATE_DB",
table="FAN_INFO",
key_pattern="*",
field="led_status",
value="yellow")
ret = match_engine.fetch(req)
assert ret["error"] == EXCEP_DICT["NO_ENTRIES"]
assert len(ret["keys"]) == 0
