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