def test_Portchannel(self, dvs, testlog):
# create port channel
db = swsscommon.DBConnector(0, dvs.redis_sock, 0)
ps = swsscommon.ProducerStateTable(db, "LAG_TABLE")
fvs = swsscommon.FieldValuePairs([("admin", "up"), ("mtu", "1500")])
ps.set("PortChannel0001", fvs)
# create port channel member
ps = swsscommon.ProducerStateTable(db, "LAG_MEMBER_TABLE")
fvs = swsscommon.FieldValuePairs([("status", "enabled")])
ps.set("PortChannel0001:Ethernet0", fvs)
time.sleep(1)
# check asic db
asicdb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
lagtbl = swsscommon.Table(asicdb, "ASIC_STATE:SAI_OBJECT_TYPE_LAG")
lags = lagtbl.getKeys()
assert len(lags) == 1
lagmtbl = swsscommon.Table(asicdb,
"ASIC_STATE:SAI_OBJECT_TYPE_LAG_MEMBER")
lagms = lagmtbl.getKeys()
assert len(lagms) == 1
(status, fvs) = lagmtbl.get(lagms[0])
fvs = dict(fvs)
assert status
assert "SAI_LAG_MEMBER_ATTR_LAG_ID" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_LAG_ID") == lags[0]
assert "SAI_LAG_MEMBER_ATTR_PORT_ID" in fvs
assert dvs.asicdb.portoidmap[fvs.pop(
"SAI_LAG_MEMBER_ATTR_PORT_ID")] == "Ethernet0"
assert "SAI_LAG_MEMBER_ATTR_INGRESS_DISABLE" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_INGRESS_DISABLE") == "false"
assert "SAI_LAG_MEMBER_ATTR_EGRESS_DISABLE" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_EGRESS_DISABLE") == "false"
assert not fvs
ps = swsscommon.ProducerStateTable(db, "LAG_MEMBER_TABLE")
fvs = swsscommon.FieldValuePairs([("status", "disabled")])
ps.set("PortChannel0001:Ethernet0", fvs)
time.sleep(1)
lagmtbl = swsscommon.Table(asicdb,
"ASIC_STATE:SAI_OBJECT_TYPE_LAG_MEMBER")
lagms = lagmtbl.getKeys()
assert len(lagms) == 1
(status, fvs) = lagmtbl.get(lagms[0])
fvs = dict(fvs)
assert status
assert "SAI_LAG_MEMBER_ATTR_LAG_ID" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_LAG_ID") == lags[0]
assert "SAI_LAG_MEMBER_ATTR_PORT_ID" in fvs
assert dvs.asicdb.portoidmap[fvs.pop(
"SAI_LAG_MEMBER_ATTR_PORT_ID")] == "Ethernet0"
assert "SAI_LAG_MEMBER_ATTR_INGRESS_DISABLE" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_INGRESS_DISABLE") == "true"
assert "SAI_LAG_MEMBER_ATTR_EGRESS_DISABLE" in fvs
assert fvs.pop("SAI_LAG_MEMBER_ATTR_EGRESS_DISABLE") == "true"
assert not fvs
# remove port channel member
ps = swsscommon.ProducerStateTable(db, "LAG_MEMBER_TABLE")
ps._del("PortChannel0001:Ethernet0")
# remove port channel
ps = swsscommon.ProducerStateTable(db, "LAG_TABLE")
ps._del("PortChannel0001")
time.sleep(1)
# check asic db
lags = lagtbl.getKeys()
assert len(lags) == 0
lagms = lagmtbl.getKeys()
assert len(lagms) == 0
def setup_db(self, dvs):
self.pdb = swsscommon.DBConnector(0, dvs.redis_sock, 0)
self.adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
self.cdb = swsscommon.DBConnector(4, dvs.redis_sock, 0)
def test_AclTableCreation(self, dvs):
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
bind_ports = ["Ethernet0", "Ethernet4"]
# create ACL_TABLE in config db
tbl = swsscommon.Table(db, "ACL_TABLE")
fvs = swsscommon.FieldValuePairs([("policy_desc", "test"), ("type", "L3"), ("ports", ",".join(bind_ports))])
tbl.set("test", fvs)
time.sleep(1)
# check acl table in asic db
test_acl_table_id = self.get_acl_table_id(dvs, adb)
# check acl table group in asic db
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP")
acl_table_groups = atbl.getKeys()
assert len(acl_table_groups) == 2
for k in acl_table_groups:
(status, fvs) = atbl.get(k)
assert status == True
for fv in fvs:
if fv[0] == "SAI_ACL_TABLE_GROUP_ATTR_ACL_STAGE":
assert fv[1] == "SAI_ACL_STAGE_INGRESS"
elif fv[0] == "SAI_ACL_TABLE_GROUP_ATTR_ACL_BIND_POINT_TYPE_LIST":
assert fv[1] == "1:SAI_ACL_BIND_POINT_TYPE_PORT"
elif fv[0] == "SAI_ACL_TABLE_GROUP_ATTR_TYPE":
assert fv[1] == "SAI_ACL_TABLE_GROUP_TYPE_PARALLEL"
else:
assert False
# check acl table group member
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP_MEMBER")
keys = atbl.getKeys()
assert len(keys) == 2
member_groups = []
for k in keys:
(status, fvs) = atbl.get(k)
assert status == True
assert len(fvs) == 3
for fv in fvs:
if fv[0] == "SAI_ACL_TABLE_GROUP_MEMBER_ATTR_ACL_TABLE_GROUP_ID":
assert fv[1] in acl_table_groups
member_groups.append(fv[1])
elif fv[0] == "SAI_ACL_TABLE_GROUP_MEMBER_ATTR_ACL_TABLE_ID":
assert fv[1] == test_acl_table_id
elif fv[0] == "SAI_ACL_TABLE_GROUP_MEMBER_ATTR_PRIORITY":
assert True
else:
assert False
assert set(member_groups) == set(acl_table_groups)
# check port binding
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_PORT")
port_groups = []
for p in [dvs.asicdb.portnamemap[portname] for portname in bind_ports]:
(status, fvs) = atbl.get(p)
for fv in fvs:
if fv[0] == "SAI_PORT_ATTR_INGRESS_ACL":
assert fv[1] in acl_table_groups
port_groups.append(fv[1])
assert set(port_groups) == set(acl_table_groups)
def get_oids(self, dvs, obj_type):
db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
tbl = swsscommon.Table(db, "ASIC_STATE:{0}".format(obj_type))
keys = tbl.getKeys()
return keys
def test_AclTableCreationBeforeLAG(self, dvs):
# prepare db and tables
self.clean_up_left_over(dvs)
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
apldb = swsscommon.DBConnector(0, dvs.redis_sock, 0)
# create acl table
tbl = swsscommon.Table(db, "ACL_TABLE")
bind_ports = ["PortChannel0003"]
fvs = swsscommon.FieldValuePairs([("policy_desc", "test_negative"),
("type", "L3"),
("ports", ",".join(bind_ports))])
tbl.set("test_LAG_2", fvs)
time.sleep(1)
# check acl table in asic db
test_acl_table_id = self.get_acl_table_id(dvs, adb)
# check acl table group in asic db
self.verify_acl_group_num(adb, 0)
# get acl table group ids and verify the id numbers
atbl = swsscommon.Table(adb,
"ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP")
acl_group_ids = atbl.getKeys()
assert len(acl_group_ids) == 0
# check acl table group member
self.verify_acl_group_member(adb, acl_group_ids, test_acl_table_id)
# get lad ids
atbl_lag = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_LAG")
lag_ids = atbl_lag.getKeys()
assert len(lag_ids) == 0
# check port binding
self.verify_acl_lag_binding(adb, lag_ids)
# create port channel
ps = swsscommon.ProducerStateTable(apldb, "LAG_TABLE")
fvs = swsscommon.FieldValuePairs([("admin", "up"), ("mtu", "1500")])
ps.set("PortChannel0003", fvs)
# create port channel member
ps = swsscommon.ProducerStateTable(apldb, "LAG_MEMBER_TABLE")
fvs = swsscommon.FieldValuePairs([("status", "enabled")])
ps.set("PortChannel0003:Ethernet20", fvs)
time.sleep(1)
# notify aclorch that port channel configured
stdb = swsscommon.DBConnector(6, dvs.redis_sock, 0)
tbl = swsscommon.Table(stdb, "LAG_TABLE")
fvs = swsscommon.FieldValuePairs([("state", "ok")])
tbl.set("PortChannel0003", fvs)
time.sleep(1)
# check acl table in asic db
test_acl_table_id = self.get_acl_table_id(dvs, adb)
# check acl table group in asic db
self.verify_acl_group_num(adb, 1)
# get acl table group ids and verify the id numbers
atbl = swsscommon.Table(adb,
"ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE_GROUP")
acl_group_ids = atbl.getKeys()
assert len(acl_group_ids) == 1
# check acl table group member
self.verify_acl_group_member(adb, acl_group_ids, test_acl_table_id)
# get lad ids
atbl_lag = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_LAG")
lag_ids = atbl_lag.getKeys()
assert len(lag_ids) == 1
# check port binding
self.verify_acl_lag_binding(adb, lag_ids)
tbl = swsscommon.Table(db, "ACL_TABLE")
tbl._del("test_LAG_2")
def get_exist_entries(dvs, table):
db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
tbl = swsscommon.Table(db, table)
return set(tbl.getKeys())
def test_port_breakout(self, dvs, port_config):
# Breakout the port from 1 to 4
'''
"Ethernet0": {
"alias": "fortyGigE0/0",
"index": "0",
"lanes": "25,26,27,28",
"speed": "40000"
},
to:
"Ethernet0": {
"alias": "tenGigE0",
"index": "0",
"lanes": "25",
"speed": "10000"
},
"Ethernet1": {
"alias": "tenGigE1",
"index": "0",
"lanes": "26",
"speed": "10000"
},
"Ethernet2": {
"alias": "tenGigE2",
"index": "0",
"lanes": "27",
"speed": "10000"
},
"Ethernet3": {
"alias": "tenGigE3",
"index": "0",
"lanes": "28",
"speed": "10000"
},
'''
# Get port config from configDB
conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0)
portTbl = swsscommon.Table(conf_db, swsscommon.CFG_PORT_TABLE_NAME)
chg_port = "Ethernet0"
keys = portTbl.getKeys()
assert chg_port in keys
(status, fvs) = portTbl.get(chg_port)
assert(status == True)
for fv in fvs:
if fv[0] == "index":
new_index = fv[1]
if fv[0] == "lanes":
new_lanes = fv[1].split(",")
# Stop swss before modifing the configDB
dvs.stop_swss()
time.sleep(1)
# breakout the port in configDB
portTbl._del(chg_port)
new_ports = ["Ethernet0","Ethernet1","Ethernet2","Ethernet3"]
new_speed = "10000"
new_alias = ["tenGigE0", "tenGigE1", "tenGigE2", "tenGigE3"]
for i in range (0 ,4):
fvs = swsscommon.FieldValuePairs([("alias", new_alias[i]),
("lanes", new_lanes[i]),
("speed", new_speed),
("index", new_index)])
portTbl.set(new_ports[i], fvs)
# start to apply new port_config.ini
dvs.start_swss()
time.sleep(5)
asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
for i in range(0,4):
port_name = 'Ethernet{0}'.format(i)
port_oid = self.getPortOid(dvs, port_name)
port_tbl = swsscommon.Table(asic_db, 'ASIC_STATE:SAI_OBJECT_TYPE_PORT:{0}'.format(port_oid))
hw_lane_value = None
for k in port_tbl.get('')[1]:
if k[0] == "SAI_PORT_ATTR_HW_LANE_LIST":
hw_lane_value = k[1]
assert hw_lane_value, "Can't get hw_lane list"
assert hw_lane_value == "1:%s" % (new_lanes[i])
def db_connect(db_name, namespace=EMPTY_NAMESPACE):
from swsscommon import swsscommon
return swsscommon.DBConnector(db_name, REDIS_TIMEOUT_MSECS, True,
namespace)
def setup_db(self, dvs):
self.asic_db = swsscommon.DBConnector(1, dvs.redis_sock, 0)
self.config_db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
self.flex_db = swsscommon.DBConnector(5, dvs.redis_sock, 0)
self.state_db = swsscommon.DBConnector(6, dvs.redis_sock, 0)
def test_AclTableCreation(self, dvs, testlog):
self.setup_db(dvs)
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
def test_SpeedAndBufferSet(self, dvs):
speed_list = ['50000', '25000', '40000', '10000', '100000']
cdb = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
cfg_port_table = swsscommon.Table(cdb, "PORT", '|')
cfg_buffer_profile_table = swsscommon.Table(cdb, "BUFFER_PROFILE", '|')
cfg_buffer_pg_table = swsscommon.Table(cdb, "BUFFER_PG", '|')
asic_port_table = swsscommon.Table(adb,
"ASIC_STATE:SAI_OBJECT_TYPE_PORT")
asic_profile_table = swsscommon.Table(
adb, "ASIC_STATE:SAI_OBJECT_TYPE_BUFFER_PROFILE")
buffer_profiles = cfg_buffer_profile_table.getKeys()
expected_buffer_profiles_num = len(buffer_profiles)
# buffers.json used for the test defines 7 static profiles:
# "ingress_lossless_profile"
# "ingress_lossy_profile"
# "egress_lossless_profile"
# "egress_lossy_profile"
# "pg_lossy_profile"
# "q_lossless_profile"
# "q_lossy_profile"
# check if they get the DB
assert expected_buffer_profiles_num == 7
# and if they were successfully created on ASIC
assert len(
asic_profile_table.getKeys()) == expected_buffer_profiles_num
for speed in speed_list:
fvs = swsscommon.FieldValuePairs([("speed", speed)])
# set same speed on all ports
for i in range(0, self.num_ports):
cfg_port_table.set("Ethernet%d" % (i * 4), fvs)
time.sleep(1) # let configuration settle down
# check the speed was set
asic_port_records = asic_port_table.getKeys()
assert len(asic_port_records) == (self.num_ports + 1) # +CPU port
num_set = 0
for k in asic_port_records:
(status, fvs) = asic_port_table.get(k)
assert status == True
for fv in fvs:
if fv[0] == "SAI_PORT_ATTR_SPEED":
assert fv[1] == speed
num_set += 1
# make sure speed is set for all "num_ports" ports
assert num_set == self.num_ports
# check number of created profiles
expected_buffer_profiles_num += 1 # new speed should add new PG profile
current_buffer_profiles = cfg_buffer_profile_table.getKeys()
assert len(current_buffer_profiles) == expected_buffer_profiles_num
# make sure the same number of profiles are created on ASIC
assert len(
asic_profile_table.getKeys()) == expected_buffer_profiles_num
# check new profile name
expected_new_profile_name = "pg_lossless_%s_300m_profile" % speed
assert current_buffer_profiles.index(
expected_new_profile_name) > -1
# check correct profile is set for all ports
pg_tables = cfg_buffer_pg_table.getKeys()
for i in range(0, self.num_ports):
expected_pg_table = "Ethernet%d|3-4" % (i * 4)
assert pg_tables.index(expected_pg_table) > -1
(status, fvs) = cfg_buffer_pg_table.get(expected_pg_table)
for fv in fvs:
if fv[0] == "profile":
assert fv[
1] == "[BUFFER_PROFILE|%s]" % expected_new_profile_name
def test_VlanMemberCreation(dvs):
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
# create vlan in config db
tbl = swsscommon.Table(db, "VLAN")
fvs = swsscommon.FieldValuePairs([("vlanid", "2")])
tbl.set("Vlan2", fvs)
time.sleep(1)
# check vlan in asic db
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_VLAN")
keys = atbl.getKeys()
assert len(keys) == 2
vlan_oid = None
for k in keys:
if k == dvs.asicdb.default_vlan_id:
continue
(status, fvs) = atbl.get(k)
assert status == True
if fvs[0][0] == "SAI_VLAN_ATTR_VLAN_ID":
assert fvs[0][1] == '2'
vlan_oid = k
assert vlan_oid != None
# create vlan member in config db
tbl = swsscommon.Table(db, "VLAN_MEMBER")
fvs = swsscommon.FieldValuePairs([("tagging_mode", "untagged")])
tbl.set("Vlan2|Ethernet0", fvs)
time.sleep(1)
# check vlan member in asic db
bridge_port_map = {}
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_BRIDGE_PORT")
keys = atbl.getKeys()
for k in keys:
(status, fvs) = atbl.get(k)
assert status == True
for fv in fvs:
if fv[0] == "SAI_BRIDGE_PORT_ATTR_PORT_ID":
bridge_port_map[k] = fv[1]
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_VLAN_MEMBER")
keys = atbl.getKeys()
assert len(keys) == 1
(status, fvs) = atbl.get(keys[0])
assert status == True
for fv in fvs:
if fv[0] == "SAI_VLAN_MEMBER_ATTR_VLAN_TAGGING_MODE":
assert fv[1] == "SAI_VLAN_TAGGING_MODE_UNTAGGED"
elif fv[0] == "SAI_VLAN_MEMBER_ATTR_VLAN_ID":
assert fv[1] == vlan_oid
elif fv[0] == "SAI_VLAN_MEMBER_ATTR_BRIDGE_PORT_ID":
assert dvs.asicdb.portoidmap[bridge_port_map[fv[1]]] == "Ethernet0"
else:
assert False
# check pvid of the port
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_PORT")
(status, fvs) = atbl.get(dvs.asicdb.portnamemap["Ethernet0"])
assert status == True
assert "SAI_PORT_ATTR_PORT_VLAN_ID" in [fv[0] for fv in fvs]
for fv in fvs:
if fv[0] == "SAI_PORT_ATTR_PORT_VLAN_ID":
assert fv[1] == "2"
# check vlan tag for the host interface
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_HOSTIF")
(status, fvs) = atbl.get(dvs.asicdb.hostifnamemap["Ethernet0"])
assert status == True
assert "SAI_HOSTIF_ATTR_VLAN_TAG" in [fv[0] for fv in fvs]
for fv in fvs:
if fv[0] == "SAI_HOSTIF_ATTR_VLAN_TAG":
assert fv[1] == "SAI_HOSTIF_VLAN_TAG_KEEP"
def test_Portchannel_lacpkey(self, dvs, testlog):
portchannelNamesAuto = [("PortChannel001", "Ethernet0", 1001),
("PortChannel002", "Ethernet4", 1002),
("PortChannel2", "Ethernet8", 12),
("PortChannel000", "Ethernet12", 1000)]
portchannelNames = [("PortChannel0003", "Ethernet16", 0),
("PortChannel0004", "Ethernet20", 0),
("PortChannel0005", "Ethernet24", 564)]
self.cdb = swsscommon.DBConnector(4, dvs.redis_sock, 0)
# Create PortChannels
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL")
fvs = swsscommon.FieldValuePairs([("admin_status", "up"),
("mtu", "9100"),
("oper_status", "up"),
("lacp_key", "auto")])
for portchannel in portchannelNamesAuto:
tbl.set(portchannel[0], fvs)
fvs_no_lacp_key = swsscommon.FieldValuePairs([("admin_status", "up"),
("mtu", "9100"),
("oper_status", "up")])
tbl.set(portchannelNames[0][0], fvs_no_lacp_key)
fvs_empty_lacp_key = swsscommon.FieldValuePairs([
("admin_status", "up"), ("mtu", "9100"), ("oper_status", "up"),
("lacp_key", "")
])
tbl.set(portchannelNames[1][0], fvs_empty_lacp_key)
fvs_set_number_lacp_key = swsscommon.FieldValuePairs([
("admin_status", "up"), ("mtu", "9100"), ("oper_status", "up"),
("lacp_key", "564")
])
tbl.set(portchannelNames[2][0], fvs_set_number_lacp_key)
time.sleep(1)
# Add members to PortChannels
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_MEMBER")
fvs = swsscommon.FieldValuePairs([("NULL", "NULL")])
for portchannel in itertools.chain(portchannelNames,
portchannelNamesAuto):
tbl.set(portchannel[0] + "|" + portchannel[1], fvs)
time.sleep(1)
# TESTS here that LACP key is valid and equls to the expected LACP key
# The expected LACP key in the number at the end of the Port-Channel name with a prefix '1'
for portchannel in itertools.chain(portchannelNames,
portchannelNamesAuto):
(exit_code,
output) = dvs.runcmd("teamdctl " + portchannel[0] + " state dump")
port_state_dump = json.loads(output)
lacp_key = port_state_dump["ports"][
portchannel[1]]["runner"]["actor_lacpdu_info"]["key"]
assert lacp_key == portchannel[2]
# remove PortChannel members
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_MEMBER")
for portchannel in itertools.chain(portchannelNames,
portchannelNamesAuto):
tbl._del(portchannel[0] + "|" + portchannel[1])
time.sleep(1)
# remove PortChannel
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL")
for portchannel in itertools.chain(portchannelNames,
portchannelNamesAuto):
tbl._del(portchannel[0])
time.sleep(1)
def test_Portchannel_oper_down(self, dvs, testlog):
self.adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
self.cdb = swsscommon.DBConnector(4, dvs.redis_sock, 0)
self.pdb = swsscommon.DBConnector(0, dvs.redis_sock, 0)
# Create 4 PortChannels
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL")
fvs = swsscommon.FieldValuePairs([("admin_status", "up"),
("mtu", "9100"),
("oper_status", "up")])
tbl.set("PortChannel001", fvs)
time.sleep(1)
tbl.set("PortChannel002", fvs)
time.sleep(1)
tbl.set("PortChannel003", fvs)
time.sleep(1)
tbl.set("PortChannel004", fvs)
time.sleep(1)
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_MEMBER")
fvs = swsscommon.FieldValuePairs([("NULL", "NULL")])
tbl.set("PortChannel001|Ethernet0", fvs)
time.sleep(1)
tbl.set("PortChannel002|Ethernet4", fvs)
time.sleep(1)
tbl.set("PortChannel003|Ethernet8", fvs)
time.sleep(1)
tbl.set("PortChannel004|Ethernet12", fvs)
time.sleep(1)
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_INTERFACE")
fvs = swsscommon.FieldValuePairs([("NULL", "NULL")])
tbl.set("PortChannel001", fvs)
tbl.set("PortChannel001|40.0.0.0/31", fvs)
time.sleep(1)
tbl.set("PortChannel002", fvs)
tbl.set("PortChannel002|40.0.0.2/31", fvs)
time.sleep(1)
tbl.set("PortChannel003", fvs)
tbl.set("PortChannel003|40.0.0.4/31", fvs)
time.sleep(1)
tbl.set("PortChannel004", fvs)
tbl.set("PortChannel004|40.0.0.6/31", fvs)
time.sleep(1)
# check application database
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel001")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 1
assert intf_entries[0] == "40.0.0.0/31"
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel002")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 1
assert intf_entries[0] == "40.0.0.2/31"
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel003")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 1
assert intf_entries[0] == "40.0.0.4/31"
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel004")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 1
assert intf_entries[0] == "40.0.0.6/31"
# set oper_status for PortChannels
ps = swsscommon.ProducerStateTable(self.pdb, "LAG_TABLE")
fvs = swsscommon.FieldValuePairs([("admin_status", "up"),
("mtu", "9100"),
("oper_status", "up")])
ps.set("PortChannel001", fvs)
ps.set("PortChannel002", fvs)
ps.set("PortChannel003", fvs)
ps.set("PortChannel004", fvs)
time.sleep(1)
dvs.runcmd("arp -s 40.0.0.1 00:00:00:00:00:01")
time.sleep(1)
dvs.runcmd("arp -s 40.0.0.3 00:00:00:00:00:03")
time.sleep(1)
dvs.runcmd("arp -s 40.0.0.5 00:00:00:00:00:05")
time.sleep(1)
dvs.runcmd("arp -s 40.0.0.7 00:00:00:00:00:07")
time.sleep(1)
ps = swsscommon.ProducerStateTable(self.pdb, "ROUTE_TABLE")
fvs = swsscommon.FieldValuePairs([
("nexthop", "40.0.0.1,40.0.0.3,40.0.0.5,40.0.0.7"),
("ifname",
"PortChannel001,PortChannel002,PortChannel003,PortChannel004")
])
ps.set("2.2.2.0/24", fvs)
time.sleep(1)
# check if route has propagated to ASIC DB
re_tbl = swsscommon.Table(self.adb,
"ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY")
found_route = False
for key in re_tbl.getKeys():
route = json.loads(key)
if route["dest"] == "2.2.2.0/24":
found_route = True
break
assert found_route
# check if route points to next hop group
nhg_tbl = swsscommon.Table(
self.adb, "ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP")
(status, fvs) = re_tbl.get(key)
for v in fvs:
if v[0] == "SAI_ROUTE_ENTRY_ATTR_NEXT_HOP_ID":
nhg_id = v[1]
(status, fvs) = nhg_tbl.get(nhg_id)
assert status
# check if next hop group consists of 4 members
nhg_member_tbl = swsscommon.Table(
self.adb, "ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER")
keys = nhg_member_tbl.getKeys()
assert len(keys) == 4
for key in keys:
(status, fvs) = nhg_member_tbl.get(key)
for v in fvs:
if v[0] == "SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID":
assert v[1] == nhg_id
# bring PortChannel down
dvs.servers[0].runcmd("ip link set down dev eth0")
time.sleep(1)
ps = swsscommon.ProducerStateTable(self.pdb, "LAG_TABLE")
fvs = swsscommon.FieldValuePairs([("admin_status", "up"),
("mtu", "9100"),
("oper_status", "down")])
ps.set("PortChannel001", fvs)
time.sleep(1)
# check if next hop group consists of 3 member
keys = nhg_member_tbl.getKeys()
assert len(keys) == 3
# remove IP address
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_INTERFACE")
tbl._del("PortChannel001|40.0.0.0/31")
tbl._del("PortChannel002|40.0.0.2/31")
tbl._del("PortChannel003|40.0.0.4/31")
tbl._del("PortChannel004|40.0.0.6/31")
time.sleep(1)
# check application database
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel001")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 0
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel002")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 0
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel003")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 0
tbl = swsscommon.Table(self.pdb, "INTF_TABLE:PortChannel004")
intf_entries = tbl.getKeys()
assert len(intf_entries) == 0
# remove PortChannel members
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL_MEMBER")
tbl._del("PortChannel001|Ethernet0")
tbl._del("PortChannel002|Ethernet4")
tbl._del("PortChannel003|Ethernet8")
tbl._del("PortChannel004|Ethernet12")
time.sleep(1)
# remove PortChannel
tbl = swsscommon.Table(self.cdb, "PORTCHANNEL")
tbl._del("PortChannel001")
tbl._del("PortChannel002")
tbl._del("PortChannel003")
tbl._del("PortChannel004")
time.sleep(1)
# Restore eth0 up
dvs.servers[0].runcmd("ip link set up dev eth0")
time.sleep(1)
def check_vxlan_tunnel(self, dvs, tunnel_name, src_ip):
asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
global loopback_id, def_vr_id
tunnel_map_id = get_created_entries(asic_db, self.ASIC_TUNNEL_MAP,
self.tunnel_map_ids, 2)
tunnel_id = get_created_entry(asic_db, self.ASIC_TUNNEL_TABLE,
self.tunnel_ids)
tunnel_term_id = get_created_entry(asic_db,
self.ASIC_TUNNEL_TERM_ENTRY,
self.tunnel_term_ids)
# check that the vxlan tunnel termination are there
assert how_many_entries_exist(
asic_db,
self.ASIC_TUNNEL_MAP) == (len(self.tunnel_map_ids) +
2), "The TUNNEL_MAP wasn't created"
assert how_many_entries_exist(
asic_db, self.ASIC_TUNNEL_MAP_ENTRY) == len(
self.tunnel_map_entry_ids), "The TUNNEL_MAP_ENTRY is created"
assert how_many_entries_exist(
asic_db,
self.ASIC_TUNNEL_TABLE) == (len(self.tunnel_ids) +
1), "The TUNNEL wasn't created"
assert how_many_entries_exist(
asic_db, self.ASIC_TUNNEL_TERM_ENTRY) == (
len(self.tunnel_term_ids) +
1), "The TUNNEL_TERM_TABLE_ENTRY wasm't created"
check_object(
asic_db, self.ASIC_TUNNEL_MAP, tunnel_map_id[0], {
'SAI_TUNNEL_MAP_ATTR_TYPE':
'SAI_TUNNEL_MAP_TYPE_VNI_TO_VIRTUAL_ROUTER_ID',
})
check_object(
asic_db, self.ASIC_TUNNEL_MAP, tunnel_map_id[1], {
'SAI_TUNNEL_MAP_ATTR_TYPE':
'SAI_TUNNEL_MAP_TYPE_VIRTUAL_ROUTER_ID_TO_VNI',
})
check_object(
asic_db, self.ASIC_TUNNEL_TABLE, tunnel_id, {
'SAI_TUNNEL_ATTR_TYPE': 'SAI_TUNNEL_TYPE_VXLAN',
'SAI_TUNNEL_ATTR_UNDERLAY_INTERFACE': loopback_id,
'SAI_TUNNEL_ATTR_DECAP_MAPPERS': '1:%s' % tunnel_map_id[0],
'SAI_TUNNEL_ATTR_ENCAP_MAPPERS': '1:%s' % tunnel_map_id[1],
'SAI_TUNNEL_ATTR_ENCAP_SRC_IP': src_ip,
})
expected_attributes = {
'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TYPE':
'SAI_TUNNEL_TERM_TABLE_ENTRY_TYPE_P2MP',
'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_VR_ID': def_vr_id,
'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_DST_IP': src_ip,
'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_TUNNEL_TYPE':
'SAI_TUNNEL_TYPE_VXLAN',
'SAI_TUNNEL_TERM_TABLE_ENTRY_ATTR_ACTION_TUNNEL_ID': tunnel_id,
}
check_object(asic_db, self.ASIC_TUNNEL_TERM_ENTRY, tunnel_term_id,
expected_attributes)
self.tunnel_map_ids.update(tunnel_map_id)
self.tunnel_ids.add(tunnel_id)
self.tunnel_term_ids.add(tunnel_term_id)
self.tunnel_map_map[tunnel_name] = tunnel_map_id
self.tunnel[tunnel_name] = tunnel_id
def test_PortFec(self, dvs, testlog):
dvs.runcmd("config interface startup Ethernet0")
dvs.runcmd("config interface ip add Ethernet0 10.0.0.0/31")
dvs.runcmd("config interface startup Ethernet4")
dvs.runcmd("config interface ip add Ethernet4 10.0.0.2/31")
dvs.servers[0].runcmd("ip link set down dev eth0") == 0
time.sleep(1)
db = swsscommon.DBConnector(0, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
tbl = swsscommon.Table(db, "PORT_TABLE")
ptbl = swsscommon.ProducerStateTable(db, "PORT_TABLE")
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_PORT")
(status, fvs) = tbl.get("Ethernet0")
assert status == True
oper_status = "unknown"
for v in fvs:
if v[0] == "oper_status":
oper_status = v[1]
break
assert oper_status == "down"
dvs.servers[0].runcmd("ip link set up dev eth0") == 0
time.sleep(1)
(status, fvs) = tbl.get("Ethernet0")
assert status == True
oper_status = "unknown"
for v in fvs:
if v[0] == "oper_status":
oper_status = v[1]
break
assert oper_status == "up"
# set fec
fvs = swsscommon.FieldValuePairs([("fec","rs"), ("speed", "1000")])
ptbl.set("Ethernet0", fvs)
time.sleep(1)
# get fec
(status, fvs) = atbl.get(dvs.asicdb.portnamemap["Ethernet0"])
assert status == True
for fv in fvs:
if fv[0] == "SAI_PORT_ATTR_FEC_MODE":
assert fv[1] == "SAI_PORT_FEC_MODE_RS"
def remove_nvgre_tunnel(self, dvs, tunnel_name):
conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock,
0)
delete_entry_tbl(conf_db, NVGRE_TUNNEL, tunnel_name)
time.sleep(1)
def db_connect(db_name):
from swsscommon import swsscommon
return swsscommon.DBConnector(db_name, REDIS_TIMEOUT_MSECS, True)
def test_recirc_port(self, dvs):
# Get port config from configDB
cfg_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0)
cfg_port_tbl = swsscommon.Table(cfg_db, swsscommon.CFG_PORT_TABLE_NAME)
indexes = []
lanes = []
keys = cfg_port_tbl.getKeys()
for port in keys:
(status, fvs) = cfg_port_tbl.get(port)
assert(status == True)
for fv in fvs:
if fv[0] == "index":
indexes.append(int(fv[1]))
if fv[0] == "lanes":
lanes.extend([int(lane) for lane in fv[1].split(",")])
# Stop swss before modifing the configDB
dvs.stop_swss()
time.sleep(1)
recirc_port_lane_base = max(lanes) + 1
recirc_port_index_base = max(indexes) + 1
# Add recirc ports to port config in configDB
recirc_port_lane_name_map = {}
for i in range(2):
name = alias = "Ethernet-Rec%s" % i
fvs = swsscommon.FieldValuePairs([("role", "Rec" if i % 2 == 0 else "Inb"),
("alias", alias),
("lanes", str(recirc_port_lane_base + i)),
("speed", "10000"),
("index", str(recirc_port_index_base + i))])
cfg_port_tbl.set(name, fvs)
# Start swss
dvs.start_swss()
time.sleep(5)
polling_config = PollingConfig(polling_interval=0.1, timeout=15, strict=True)
# Verify recirc ports in port table in applDB
for i in range(2):
name = alias = "Ethernet-Rec%s" % i
dvs.get_app_db().wait_for_field_match(swsscommon.APP_PORT_TABLE_NAME, name,
{"role" : "Rec" if i % 2 == 0 else "Inb",
"alias" : name,
"lanes" : str(recirc_port_lane_base + i),
"speed" : "10000",
"index" : str(recirc_port_index_base + i) },
polling_config=polling_config)
# Verify recirc port lanes in asicDB
asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
asic_db_lanes_tbl = swsscommon.Table(asic_db, "LANES")
def _access_function():
lanes = asic_db_lanes_tbl.get('')[1]
if len(lanes) == 0:
return (False, None)
recirc_port_lanes = [recirc_port_lane_base, recirc_port_lane_base + 1]
for lane in lanes:
lane_num = int(lane[0])
if int(lane_num) in recirc_port_lanes:
recirc_port_lanes.remove( lane_num )
return (not recirc_port_lanes, None)
wait_for_result(_access_function, polling_config=polling_config)
def test_route_nhg(dvs, testlog):
config_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0)
intf_tbl = swsscommon.Table(config_db, "INTERFACE")
fvs = swsscommon.FieldValuePairs([("NULL", "NULL")])
intf_tbl.set("Ethernet0", fvs)
intf_tbl.set("Ethernet4", fvs)
intf_tbl.set("Ethernet8", fvs)
intf_tbl.set("Ethernet0|10.0.0.0/31", fvs)
intf_tbl.set("Ethernet4|10.0.0.2/31", fvs)
intf_tbl.set("Ethernet8|10.0.0.4/31", fvs)
dvs.runcmd("ifconfig Ethernet0 up")
dvs.runcmd("ifconfig Ethernet4 up")
dvs.runcmd("ifconfig Ethernet8 up")
dvs.runcmd("arp -s 10.0.0.1 00:00:00:00:00:01")
dvs.runcmd("arp -s 10.0.0.3 00:00:00:00:00:02")
dvs.runcmd("arp -s 10.0.0.5 00:00:00:00:00:03")
dvs.servers[0].runcmd("ip link set down dev eth0") == 0
dvs.servers[1].runcmd("ip link set down dev eth0") == 0
dvs.servers[2].runcmd("ip link set down dev eth0") == 0
dvs.servers[0].runcmd("ip link set up dev eth0") == 0
dvs.servers[1].runcmd("ip link set up dev eth0") == 0
dvs.servers[2].runcmd("ip link set up dev eth0") == 0
db = swsscommon.DBConnector(0, dvs.redis_sock, 0)
ps = swsscommon.ProducerStateTable(db, "ROUTE_TABLE")
fvs = swsscommon.FieldValuePairs([
("nexthop", "10.0.0.1,10.0.0.3,10.0.0.5"),
("ifname", "Ethernet0,Ethernet4,Ethernet8")
])
ps.set("2.2.2.0/24", fvs)
time.sleep(1)
# check if route was propagated to ASIC DB
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
rtbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY")
nhgtbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP")
nhg_member_tbl = swsscommon.Table(
adb, "ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER")
keys = rtbl.getKeys()
found_route = False
for k in keys:
rt_key = json.loads(k)
if rt_key['dest'] == "2.2.2.0/24":
found_route = True
break
assert found_route
# assert the route points to next hop group
(status, fvs) = rtbl.get(k)
for v in fvs:
if v[0] == "SAI_ROUTE_ENTRY_ATTR_NEXT_HOP_ID":
nhgid = v[1]
(status, fvs) = nhgtbl.get(nhgid)
assert status
keys = nhg_member_tbl.getKeys()
assert len(keys) == 3
for k in keys:
(status, fvs) = nhg_member_tbl.get(k)
for v in fvs:
if v[0] == "SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID":
assert v[1] == nhgid
# bring links down one-by-one
for i in [0, 1, 2]:
dvs.servers[i].runcmd("ip link set down dev eth0") == 0
time.sleep(1)
tbl = swsscommon.Table(db, "PORT_TABLE")
(status, fvs) = tbl.get("Ethernet%d" % (i * 4))
assert status == True
oper_status = "unknown"
for v in fvs:
if v[0] == "oper_status":
oper_status = v[1]
break
assert oper_status == "down"
keys = nhg_member_tbl.getKeys()
assert len(keys) == 2 - i
# bring links up one-by-one
for i in [0, 1, 2]:
dvs.servers[i].runcmd("ip link set up dev eth0") == 0
time.sleep(1)
tbl = swsscommon.Table(db, "PORT_TABLE")
(status, fvs) = tbl.get("Ethernet%d" % (i * 4))
assert status == True
oper_status = "unknown"
for v in fvs:
if v[0] == "oper_status":
oper_status = v[1]
break
assert oper_status == "up"
keys = nhg_member_tbl.getKeys()
assert len(keys) == i + 1
for k in keys:
(status, fvs) = nhg_member_tbl.get(k)
for v in fvs:
if v[0] == "SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID":
assert v[1] == nhgid
def enable_unittests(self, dvs, status):
db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
ntf = swsscommon.NotificationProducer(db, "SAI_VS_UNITTEST_CHANNEL")
fvp = swsscommon.FieldValuePairs()
ntf.send("enable_unittests", status, fvp)
def setup_db(self):
self.pdb = swsscommon.DBConnector(0, self.redis_sock, 0)
self.adb = swsscommon.DBConnector(1, self.redis_sock, 0)
self.cdb = swsscommon.DBConnector(4, self.redis_sock, 0)
self.sdb = swsscommon.DBConnector(6, self.redis_sock, 0)
def test_RulesWithDiffMaskLengths(self, dvs):
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
bind_ports = ["Ethernet0", "Ethernet4"]
# create ACL_TABLE in config db
tbl = swsscommon.Table(db, "ACL_TABLE")
fvs = swsscommon.FieldValuePairs([("policy_desc", "test"),
("type", "L3"),
("ports", ",".join(bind_ports))])
tbl.set("test_subnet", fvs)
time.sleep(2)
subnet_mask_rules = 0
#create ACL rules
tbl = swsscommon.Table(db, "ACL_RULE")
rules = [[("PRIORITY", "10"), ("PACKET_ACTION", "FORWARD"),
("SRC_IP", "23.103.0.0/18")],
[("PRIORITY", "20"), ("PACKET_ACTION", "FORWARD"),
("SRC_IP", "104.44.94.0/23")],
[("PRIORITY", "30"), ("PACKET_ACTION", "FORWARD"),
("DST_IP", "172.16.0.0/12")],
[("PRIORITY", "40"), ("PACKET_ACTION", "FORWARD"),
("DST_IP", "100.64.0.0/10")],
[("PRIORITY", "50"), ("PACKET_ACTION", "FORWARD"),
("DST_IP", "104.146.32.0/19")],
[("PRIORITY", "60"), ("PACKET_ACTION", "FORWARD"),
("SRC_IP", "21.0.0.0/8")]]
#used to verify how ACL rules are programmed in ASICDB
#order must match the list of rules
verifs = [{
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'10',
'SAI_ACL_ENTRY_ATTR_FIELD_SRC_IP':
'23.103.0.0&mask:255.255.192.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'20',
'SAI_ACL_ENTRY_ATTR_FIELD_SRC_IP':
'104.44.94.0&mask:255.255.254.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'30',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'172.16.0.0&mask:255.240.0.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'40',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'100.64.0.0&mask:255.192.0.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'50',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'104.146.32.0&mask:255.255.224.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'60',
'SAI_ACL_ENTRY_ATTR_FIELD_SRC_IP':
'21.0.0.0&mask:255.0.0.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}]
#insert rules
for rule in rules:
fvs = swsscommon.FieldValuePairs(rule)
subnet_mask_rules += 1
tbl.set("test_subnet|acl_test_rule%s" % subnet_mask_rules, fvs)
time.sleep(1)
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_ENTRY")
keys = atbl.getKeys()
acl_entry = [
k for k in keys if k not in dvs.asicdb.default_acl_entries
]
assert len(acl_entry) == subnet_mask_rules
#match each entry to its corresponding verification
matched_masks = 0
for entry in acl_entry:
(status, fvs) = atbl.get(entry)
assert status == True
assert len(fvs) == 6
#helper function
if self.check_rule_existence(dict(fvs), rules, verifs):
matched_masks += 1
assert matched_masks == subnet_mask_rules
while subnet_mask_rules > 0:
tbl._del("test_subnet|acl_test_rule%s" % subnet_mask_rules)
subnet_mask_rules -= 1
time.sleep(1)
(status, fvs) = atbl.get(acl_entry[0])
assert status == False
tbl = swsscommon.Table(db, "ACL_TABLE")
tbl._del("test_subnet")
time.sleep(1)
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE")
keys = atbl.getKeys()
assert len(keys) >= 1
def __init__(self, dvs):
self.appl_db = swsscommon.DBConnector(swsscommon.APPL_DB, dvs.redis_sock, 0)
self.neighTbl = swsscommon.Table(self.appl_db, "NEIGH_TABLE")
def test_InsertAclRuleBetweenPriorities(self, dvs):
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
bind_ports = ["Ethernet0", "Ethernet4"]
# create ACL_TABLE in config db
tbl = swsscommon.Table(db, "ACL_TABLE")
fvs = swsscommon.FieldValuePairs([("policy_desc", "test"),
("type", "L3"),
("ports", ",".join(bind_ports))])
tbl.set("test_insert", fvs)
time.sleep(2)
num_rules = 0
#create ACL rules
tbl = swsscommon.Table(db, "ACL_RULE")
rules = [[("PRIORITY", "10"), ("PACKET_ACTION", "DROP"),
("SRC_IP", "10.0.0.0/32")],
[("PRIORITY", "20"), ("PACKET_ACTION", "DROP"),
("DST_IP", "104.44.94.0/23")],
[("PRIORITY", "30"), ("PACKET_ACTION", "DROP"),
("DST_IP", "192.168.0.16/32")],
[("PRIORITY", "40"), ("PACKET_ACTION", "FORWARD"),
("DST_IP", "100.64.0.0/10")]]
#used to verify how ACL rules are programmed in ASICDB
verifs = [{
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'10',
'SAI_ACL_ENTRY_ATTR_FIELD_SRC_IP':
'10.0.0.0&mask:255.255.255.255',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_DROP'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'20',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'104.44.94.0&mask:255.255.254.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_DROP'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'30',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'192.168.0.16&mask:255.255.255.255',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_DROP'
}, {
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'40',
'SAI_ACL_ENTRY_ATTR_FIELD_DST_IP':
'100.64.0.0&mask:255.192.0.0',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_FORWARD'
}]
#insert rules
for rule in rules:
fvs = swsscommon.FieldValuePairs(rule)
num_rules += 1
tbl.set("test_insert|acl_test_rule%s" % num_rules, fvs)
time.sleep(1)
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_ENTRY")
keys = atbl.getKeys()
#assert that first set of rules are programmed
acl_entry = [
k for k in keys if k not in dvs.asicdb.default_acl_entries
]
assert len(acl_entry) == num_rules
#insert new rule with odd priority
tbl = swsscommon.Table(db, "ACL_RULE")
insertrule = [("PRIORITY", "21"), ("PACKET_ACTION", "DROP"),
("ETHER_TYPE", "4660")]
#create verification for that rule
verifs.append({
'SAI_ACL_ENTRY_ATTR_PRIORITY':
'21',
'SAI_ACL_ENTRY_ATTR_FIELD_ETHER_TYPE':
'4660&mask:0xffff',
'SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION':
'SAI_PACKET_ACTION_DROP'
})
rules.append(insertrule)
fvs = swsscommon.FieldValuePairs(insertrule)
num_rules += 1
tbl.set("test_insert|acl_test_rule%s" % num_rules, fvs)
time.sleep(1)
#assert all rules are programmed
keys = atbl.getKeys()
acl_entry = [
k for k in keys if k not in dvs.asicdb.default_acl_entries
]
assert len(acl_entry) == num_rules
#match each entry to its corresponding verification
matched_rules = 0
for entry in acl_entry:
(status, fvs) = atbl.get(entry)
assert status == True
assert len(fvs) == 6
#helper function
if self.check_rule_existence(dict(fvs), rules, verifs):
matched_rules += 1
assert num_rules == matched_rules
#cleanup
while num_rules > 0:
tbl._del("test_insert|acl_test_rule%s" % num_rules)
num_rules -= 1
time.sleep(1)
(status, fvs) = atbl.get(acl_entry[0])
assert status == False
tbl = swsscommon.Table(db, "ACL_TABLE")
tbl._del("test_insert")
time.sleep(1)
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_TABLE")
keys = atbl.getKeys()
# only the default table was left
assert len(keys) >= 1
def generator_SelectMemoryLeak():
app_db = swsscommon.DBConnector("APPL_DB", 0, True)
t = swsscommon.Table(app_db, "TABLE")
for i in range(int(N / 2)):
table_set(t, "up")
table_set(t, "down")
def register_db(self, db_name):
""" Get DB connector, if not there """
if db_name not in self.db_connectors:
self.db_connectors[db_name] = swsscommon.DBConnector(db_name, 0)
def test_route_fgnhg(self, dvs, testlog):
app_db = dvs.get_app_db()
asic_db = dvs.get_asic_db()
config_db = dvs.get_config_db()
state_db = dvs.get_state_db()
fvs_nul = {"NULL": "NULL"}
NUM_NHs = 6
fg_nhg_name = "fgnhg_v4"
fg_nhg_prefix = "2.2.2.0/24"
bucket_size = 60
ip_to_if_map = {}
fvs = {"bucket_size": str(bucket_size)}
create_entry(config_db, FG_NHG, fg_nhg_name, fvs)
fvs = {"FG_NHG": fg_nhg_name}
create_entry(config_db, FG_NHG_PREFIX, fg_nhg_prefix, fvs)
for i in range(0, NUM_NHs):
if_name_key = "Ethernet" + str(i * 4)
ip_pref_key = "Ethernet" + str(i * 4) + "|10.0.0." + str(
i * 2) + "/31"
create_entry(config_db, IF_TB, if_name_key, fvs_nul)
create_entry(config_db, IF_TB, ip_pref_key, fvs_nul)
dvs.runcmd("config interface startup " + if_name_key)
dvs.servers[i].runcmd("ip link set down dev eth0") == 0
dvs.servers[i].runcmd("ip link set up dev eth0") == 0
bank = 0
if i >= NUM_NHs / 2:
bank = 1
fvs = {"FG_NHG": fg_nhg_name, "bank": str(bank)}
create_entry(config_db, FG_NHG_MEMBER, "10.0.0." + str(1 + i * 2),
fvs)
ip_to_if_map["10.0.0." + str(1 + i * 2)] = if_name_key
# Wait for the software to receive the entries
time.sleep(1)
asic_routes_count = len(asic_db.get_keys(ASIC_ROUTE_TB))
ps = swsscommon.ProducerStateTable(app_db.db_connection, ROUTE_TB)
fvs = swsscommon.FieldValuePairs([
("nexthop", "10.0.0.7,10.0.0.9,10.0.0.11"),
("ifname", "Ethernet12,Ethernet16,Ethernet20")
])
ps.set(fg_nhg_prefix, fvs)
# No ASIC_DB entry we can wait for since ARP is not resolved yet,
# We just use sleep so that the sw receives this entry
time.sleep(1)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
rtbl = swsscommon.Table(adb, ASIC_ROUTE_TB)
keys = rtbl.getKeys()
found_route = False
for k in keys:
rt_key = json.loads(k)
if rt_key['dest'] == fg_nhg_prefix:
found_route = True
break
# Since we didn't populate ARP yet, the route shouldn't be programmed
assert (found_route == False)
dvs.runcmd("arp -s 10.0.0.1 00:00:00:00:00:01")
dvs.runcmd("arp -s 10.0.0.3 00:00:00:00:00:02")
dvs.runcmd("arp -s 10.0.0.5 00:00:00:00:00:03")
dvs.runcmd("arp -s 10.0.0.9 00:00:00:00:00:05")
dvs.runcmd("arp -s 10.0.0.11 00:00:00:00:00:06")
keys = asic_db.wait_for_n_keys(ASIC_ROUTE_TB, asic_routes_count + 1)
nhgid = asic_route_exists_and_is_nhg(asic_db, keys, fg_nhg_prefix)
assert nhgid is not None
validate_asic_nhg(asic_db, nhgid, bucket_size)
nh_oid_map = get_nh_oid_map(asic_db)
### Test scenarios with bank 0 having 0 members up
# ARP is not resolved for 10.0.0.7, so fg nhg should be created without 10.0.0.7
nh_memb_exp_count = {"10.0.0.9": 30, "10.0.0.11": 30}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# Resolve ARP for 10.0.0.7
asic_nh_count = len(
asic_db.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP"))
dvs.runcmd("arp -s 10.0.0.7 00:00:00:00:00:04")
asic_db.wait_for_n_keys("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP",
asic_nh_count + 1)
nh_oid_map = get_nh_oid_map(asic_db)
# Now that ARP was resolved, 10.0.0.7 should be added as a valid fg nhg member
nh_memb_exp_count = {"10.0.0.7": 20, "10.0.0.9": 20, "10.0.0.11": 20}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# Bring down 1 next hop in bank 1
nh_memb_exp_count = {"10.0.0.7": 30, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring up 1 next hop in bank 1
nh_memb_exp_count = {"10.0.0.7": 20, "10.0.0.9": 20, "10.0.0.11": 20}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring up some next-hops in bank 0 for the 1st time
nh_memb_exp_count = {
"10.0.0.1": 10,
"10.0.0.3": 10,
"10.0.0.5": 10,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring down 1 next-hop from bank 0, and 2 next-hops from bank 1
nh_memb_exp_count = {"10.0.0.1": 15, "10.0.0.5": 15, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring down 1 member and bring up 1 member in bank 0 at the same time
nh_memb_exp_count = {"10.0.0.1": 15, "10.0.0.3": 15, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring down 2 members and bring up 1 member in bank 0 at the same time
nh_memb_exp_count = {"10.0.0.5": 30, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring up 2 members and bring down 1 member in bank 0 at the same time
nh_memb_exp_count = {"10.0.0.1": 15, "10.0.0.3": 15, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bringup arbitrary # of next-hops from both banks at the same time
nh_memb_exp_count = {
"10.0.0.1": 10,
"10.0.0.3": 10,
"10.0.0.5": 10,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bring all next-hops in bank 1 down
nh_memb_exp_count = {"10.0.0.1": 20, "10.0.0.3": 20, "10.0.0.5": 20}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Make next-hop changes to bank 0 members, given bank 1 is still down
nh_memb_exp_count = {"10.0.0.1": 30, "10.0.0.5": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Bringup 1 member in bank 1 again
nh_memb_exp_count = {"10.0.0.1": 15, "10.0.0.5": 15, "10.0.0.11": 30}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Test 2nd,3rd memb up in bank
nh_memb_exp_count = {
"10.0.0.1": 15,
"10.0.0.5": 15,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# bring all links down one by one
shutdown_link(dvs, app_db, 0)
nh_memb_exp_count = {
"10.0.0.5": 30,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
shutdown_link(dvs, app_db, 2)
nh_memb_exp_count = {"10.0.0.7": 20, "10.0.0.9": 20, "10.0.0.11": 20}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
shutdown_link(dvs, app_db, 3)
nh_memb_exp_count = {"10.0.0.9": 30, "10.0.0.11": 30}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
shutdown_link(dvs, app_db, 4)
nh_memb_exp_count = {"10.0.0.11": 60}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# Bring down last link, there shouldn't be a crash or other bad orchagent state because of this
shutdown_link(dvs, app_db, 5)
# Nothing to check for in this case, sleep 1s for the shutdown to reach sw
time.sleep(1)
# bring all links up one by one
startup_link(dvs, app_db, 3)
startup_link(dvs, app_db, 4)
startup_link(dvs, app_db, 5)
nh_memb_exp_count = {"10.0.0.7": 20, "10.0.0.9": 20, "10.0.0.11": 20}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
startup_link(dvs, app_db, 2)
nh_memb_exp_count = {
"10.0.0.5": 30,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
startup_link(dvs, app_db, 0)
nh_memb_exp_count = {
"10.0.0.1": 15,
"10.0.0.5": 15,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# remove fgnhg member
remove_entry(config_db, "FG_NHG_MEMBER", "10.0.0.1")
nh_memb_exp_count = {
"10.0.0.5": 30,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# add fgnhg member
fvs = {"FG_NHG": fg_nhg_name, "bank": "0"}
create_entry(config_db, FG_NHG_MEMBER, "10.0.0.1", fvs)
nh_memb_exp_count = {
"10.0.0.1": 15,
"10.0.0.5": 15,
"10.0.0.7": 10,
"10.0.0.9": 10,
"10.0.0.11": 10
}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# Remove route
asic_rt_key = get_asic_route_key(asic_db, fg_nhg_prefix)
ps._del(fg_nhg_prefix)
# validate routes and nhg member in asic db, route entry in state db are removed
asic_db.wait_for_deleted_entry(ASIC_ROUTE_TB, asic_rt_key)
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, 0)
state_db.wait_for_n_keys("FG_ROUTE_TABLE", 0)
remove_entry(config_db, "FG_NHG_PREFIX", fg_nhg_prefix)
# Nothing we can wait for in terms of db entries, we sleep here
# to give the sw enough time to delete the entry
time.sleep(1)
# Add an ECMP route, since we deleted the FG_NHG_PREFIX it should see
# standard(non-Fine grained) ECMP behavior
asic_routes_count = len(asic_db.get_keys(ASIC_ROUTE_TB))
fvs = swsscommon.FieldValuePairs([
("nexthop", "10.0.0.7,10.0.0.9,10.0.0.11"),
("ifname", "Ethernet12,Ethernet16,Ethernet20")
])
ps.set(fg_nhg_prefix, fvs)
keys = asic_db.wait_for_n_keys(ASIC_ROUTE_TB, asic_routes_count + 1)
nhgid = asic_route_exists_and_is_nhg(asic_db, keys, fg_nhg_prefix)
assert nhgid is not None
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, 3)
# add fgnhg prefix: The regular route should transition to fine grained ECMP
fvs = {"FG_NHG": fg_nhg_name}
create_entry(config_db, FG_NHG_PREFIX, fg_nhg_prefix, fvs)
# Validate the transistion to Fine Grained ECMP
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, bucket_size)
keys = asic_db.wait_for_n_keys(ASIC_ROUTE_TB, asic_routes_count + 1)
nhgid = asic_route_exists_and_is_nhg(asic_db, keys, fg_nhg_prefix)
validate_asic_nhg(asic_db, nhgid, bucket_size)
nh_oid_map = {}
nh_oid_map = get_nh_oid_map(asic_db)
nh_memb_exp_count = {"10.0.0.7": 20, "10.0.0.9": 20, "10.0.0.11": 20}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# remove fgnhg prefix: The fine grained route should transition to regular ECMP/route
remove_entry(config_db, "FG_NHG_PREFIX", fg_nhg_prefix)
# Validate regular ECMP
validate_asic_nhg_regular_ecmp(asic_db, fg_nhg_prefix)
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, 3)
state_db.wait_for_n_keys("FG_ROUTE_TABLE", 0)
# remove prefix entry
asic_rt_key = get_asic_route_key(asic_db, fg_nhg_prefix)
ps._del(fg_nhg_prefix)
asic_db.wait_for_deleted_entry(ASIC_ROUTE_TB, asic_rt_key)
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, 0)
# Cleanup all FG, arp and interface
remove_entry(config_db, "FG_NHG", fg_nhg_name)
for i in range(0, NUM_NHs):
if_name_key = "Ethernet" + str(i * 4)
ip_pref_key = "Ethernet" + str(i * 4) + "|10.0.0." + str(
i * 2) + "/31"
remove_entry(config_db, IF_TB, if_name_key)
remove_entry(config_db, IF_TB, ip_pref_key)
dvs.runcmd("config interface shutdown " + if_name_key)
dvs.servers[i].runcmd("ip link set down dev eth0") == 0
remove_entry(config_db, "FG_NHG_MEMBER",
"10.0.0." + str(1 + i * 2))
### Create new set of entries with a greater number of FG members and
### bigger bucket size such that the # of nhs are not divisible by
### bucket size.
fg_nhg_name = "new_fgnhg_v4"
fg_nhg_prefix = "3.3.3.0/24"
# Test with non-divisible bucket size
bucket_size = 128
NUM_NHs = 10
ip_to_if_map = {}
nh_oid_map = {}
# Initialize base config
fvs = {"bucket_size": str(bucket_size)}
create_entry(config_db, FG_NHG, fg_nhg_name, fvs)
fvs = {"FG_NHG": fg_nhg_name}
create_entry(config_db, FG_NHG_PREFIX, fg_nhg_prefix, fvs)
for i in range(0, NUM_NHs):
if_name_key = "Ethernet" + str(i * 4)
ip_pref_key = "Ethernet" + str(i * 4) + "|10.0.0." + str(
i * 2) + "/31"
create_entry(config_db, IF_TB, if_name_key, fvs_nul)
create_entry(config_db, IF_TB, ip_pref_key, fvs_nul)
dvs.runcmd("config interface startup " + if_name_key)
shutdown_link(dvs, app_db, i)
startup_link(dvs, app_db, i)
bank = 1
if i >= NUM_NHs / 2:
bank = 0
fvs = {"FG_NHG": fg_nhg_name, "bank": str(bank)}
create_entry(config_db, FG_NHG_MEMBER, "10.0.0." + str(1 + i * 2),
fvs)
ip_to_if_map["10.0.0." + str(1 + i * 2)] = if_name_key
dvs.runcmd("arp -s 10.0.0." + str(1 + i * 2) + " 00:00:00:00:00:" +
str(1 + i * 2))
# Program the route
asic_routes_count = len(asic_db.get_keys(ASIC_ROUTE_TB))
fvs = swsscommon.FieldValuePairs([("nexthop", "10.0.0.1,10.0.0.11"),
("ifname", "Ethernet0,Ethernet20")])
ps.set(fg_nhg_prefix, fvs)
# Validate that the correct ASIC DB elements were setup per Fine Grained ECMP
keys = asic_db.wait_for_n_keys(ASIC_ROUTE_TB, asic_routes_count + 1)
nhgid = asic_route_exists_and_is_nhg(asic_db, keys, fg_nhg_prefix)
assert nhgid is not None
validate_asic_nhg(asic_db, nhgid, bucket_size)
nh_oid_map = get_nh_oid_map(asic_db)
# Test addition of route with 0 members in bank
nh_memb_exp_count = {"10.0.0.1": 64, "10.0.0.11": 64}
validate_fine_grained_asic_n_state_db_entries(asic_db, state_db,
ip_to_if_map,
nh_memb_exp_count,
nh_oid_map, nhgid,
bucket_size)
# Add 2 nhs to both bank 0 and bank 1
nh_memb_exp_count = {
"10.0.0.1": 22,
"10.0.0.3": 21,
"10.0.0.5": 21,
"10.0.0.11": 22,
"10.0.0.13": 21,
"10.0.0.15": 21
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Add 2 more nhs to both bank 0 and bank 1
nh_memb_exp_count = {
"10.0.0.1": 13,
"10.0.0.3": 13,
"10.0.0.5": 13,
"10.0.0.7": 12,
"10.0.0.9": 13,
"10.0.0.11": 13,
"10.0.0.13": 13,
"10.0.0.15": 13,
"10.0.0.17": 12,
"10.0.0.19": 13
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Remove 1 nh from bank 0 and remove 2 nhs from bank 1
nh_memb_exp_count = {
"10.0.0.3": 16,
"10.0.0.5": 16,
"10.0.0.7": 16,
"10.0.0.9": 16,
"10.0.0.11": 22,
"10.0.0.13": 21,
"10.0.0.19": 21
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Remove 1 nh from bank 0 and add 1 nh to bank 1
nh_memb_exp_count = {
"10.0.0.3": 22,
"10.0.0.7": 21,
"10.0.0.9": 21,
"10.0.0.13": 16,
"10.0.0.15": 16,
"10.0.0.17": 16,
"10.0.0.19": 16
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Remove 2 nh from bank 0 and remove 3 nh from bank 1
nh_memb_exp_count = {"10.0.0.7": 64, "10.0.0.11": 64}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Add 2 nhs to bank 0 and remove all nh from bank 1
nh_memb_exp_count = {"10.0.0.5": 42, "10.0.0.7": 44, "10.0.0.9": 42}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Add 2 nhs to bank 0 and add 1 nh to bank 1
nh_memb_exp_count = {
"10.0.0.1": 12,
"10.0.0.3": 13,
"10.0.0.5": 13,
"10.0.0.7": 13,
"10.0.0.9": 13,
"10.0.0.11": 64
}
program_route_and_validate_fine_grained_ecmp(
app_db.db_connection, asic_db, state_db, ip_to_if_map,
fg_nhg_prefix, nh_memb_exp_count, nh_oid_map, nhgid, bucket_size)
# Remove route
# remove prefix entry
asic_rt_key = get_asic_route_key(asic_db, fg_nhg_prefix)
ps._del(fg_nhg_prefix)
asic_db.wait_for_deleted_entry(ASIC_ROUTE_TB, asic_rt_key)
asic_db.wait_for_n_keys(ASIC_NHG_MEMB, 0)
remove_entry(config_db, "FG_NHG_PREFIX", fg_nhg_prefix)
def test_V6AclRuleL4DstPortRange(self, dvs):
"""
hmset ACL_RULE|test-aclv6|test_rule10 priority 1010 PACKET_ACTION DROP L4_DST_PORT_RANGE 101-200
"""
db = swsscommon.DBConnector(4, dvs.redis_sock, 0)
adb = swsscommon.DBConnector(1, dvs.redis_sock, 0)
# create acl rule
tbl = swsscommon.Table(db, "ACL_RULE")
fvs = swsscommon.FieldValuePairs([("priority", "1010"), ("PACKET_ACTION", "DROP"), ("L4_DST_PORT_RANGE", "101-200")])
tbl.set("test-aclv6|test_rule10", fvs)
time.sleep(1)
test_acl_table_id = self.get_acl_table_id(dvs, adb)
# check acl table in asic db
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_ENTRY")
keys = atbl.getKeys()
acl_entry = [k for k in keys if k not in dvs.asicdb.default_acl_entries]
assert len(acl_entry) == 1
(status, fvs) = atbl.get(acl_entry[0])
assert status == True
assert len(fvs) == 6
for fv in fvs:
if fv[0] == "SAI_ACL_ENTRY_ATTR_TABLE_ID":
assert fv[1] == test_acl_table_id
elif fv[0] == "SAI_ACL_ENTRY_ATTR_ADMIN_STATE":
assert fv[1] == "true"
elif fv[0] == "SAI_ACL_ENTRY_ATTR_PRIORITY":
assert fv[1] == "1010"
elif fv[0] == "SAI_ACL_ENTRY_ATTR_ACTION_COUNTER":
assert True
elif fv[0] == "SAI_ACL_ENTRY_ATTR_FIELD_ACL_RANGE_TYPE":
aclrange = fv[1]
elif fv[0] == "SAI_ACL_ENTRY_ATTR_ACTION_PACKET_ACTION":
assert fv[1] == "SAI_PACKET_ACTION_DROP"
else:
assert False
atbl = swsscommon.Table(adb, "ASIC_STATE:SAI_OBJECT_TYPE_ACL_RANGE")
aclrange_obj = aclrange.split(":", 1)[1]
(status, fvs) = atbl.get(aclrange_obj)
assert status == True
assert len(fvs) == 2
for fv in fvs:
if fv[0] == "SAI_ACL_RANGE_ATTR_TYPE":
assert fv[1] == "SAI_ACL_RANGE_TYPE_L4_DST_PORT_RANGE"
elif fv[0] == "SAI_ACL_RANGE_ATTR_LIMIT":
assert fv[1] == "101,200"
else:
assert False
# remove acl rule
tbl._del("test-aclv6|test_rule10")
time.sleep(1)
(status, fvs) = atbl.get(acl_entry[0])
assert status == False
def create_vxlan_tunnel_entry(dvs, tunnel_name, tunnel_map_entry_name,
tunnel_map_map, vlan, vni_id, tunnel_map_ids,
tunnel_map_entry_ids, tunnel_ids,
tunnel_term_ids):
asic_db = swsscommon.DBConnector(swsscommon.ASIC_DB, dvs.redis_sock, 0)
conf_db = swsscommon.DBConnector(swsscommon.CONFIG_DB, dvs.redis_sock, 0)
# Check source information
assert how_many_entries_exist(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP") == len(
tunnel_map_ids), "The initial state is incorrect"
assert how_many_entries_exist(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY") == len(
tunnel_map_entry_ids), "The initial state is incorrect"
assert how_many_entries_exist(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL") == len(
tunnel_ids), "The initial state is incorrect"
assert how_many_entries_exist(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_TERM_TABLE_ENTRY") == len(
tunnel_term_ids), "The initial state is incorrect"
# create the VXLAN tunnel Term entry in Config DB
create_entry_tbl(
conf_db,
"VXLAN_TUNNEL_MAP",
'|',
"%s|%s" % (tunnel_name, tunnel_map_entry_name),
[
("vni", vni_id),
("vlan", vlan),
],
)
if (tunnel_map_map.get(tunnel_name) is None):
tunnel_map_id = get_created_entry(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP", tunnel_map_ids)
else:
tunnel_map_id = tunnel_map_map[tunnel_name]
tunnel_map_entry_id = get_created_entry(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY",
tunnel_map_entry_ids)
# check that the vxlan tunnel termination are there
assert how_many_entries_exist(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY") == (
len(tunnel_map_entry_ids) +
1), "The TUNNEL_MAP_ENTRY is created too early"
vlan_id = vlan[4:]
check_object(
asic_db, "ASIC_STATE:SAI_OBJECT_TYPE_TUNNEL_MAP_ENTRY",
tunnel_map_entry_id, {
'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP_TYPE':
'SAI_TUNNEL_MAP_TYPE_VNI_TO_VLAN_ID',
'SAI_TUNNEL_MAP_ENTRY_ATTR_TUNNEL_MAP': tunnel_map_id,
'SAI_TUNNEL_MAP_ENTRY_ATTR_VNI_ID_KEY': vni_id,
'SAI_TUNNEL_MAP_ENTRY_ATTR_VLAN_ID_VALUE': vlan_id,
})
tunnel_map_entry_ids.add(tunnel_map_entry_id)
return
