void translate_rid_to_vid_list(
_In_ sai_object_type_t object_type,
_In_ uint32_t attr_count,
_In_ sai_attribute_t *attr_list)
{
SWSS_LOG_ENTER();
// we receive real id's here, if they are new then create new id
// for them and put in db, if entry exists in db, use it
for (uint32_t i = 0; i < attr_count; i++)
{
sai_attribute_t &attr = attr_list[i];
sai_attr_serialization_type_t serialization_type;
sai_status_t status = sai_get_serialization_type(object_type, attr.id, serialization_type);
if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_ERROR("unable to find serialization type for object type %x, attribute %x", object_type, attr.id);
exit(EXIT_FAILURE);
}
switch (serialization_type)
{
case SAI_SERIALIZATION_TYPE_OBJECT_ID:
attr.value.oid = translate_rid_to_vid(attr.value.oid);
break;
case SAI_SERIALIZATION_TYPE_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_ID:
attr.value.aclfield.data.oid = translate_rid_to_vid(attr.value.aclfield.data.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_FIELD_DATA_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.aclfield.data.objlist);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_ID:
attr.value.aclaction.parameter.oid = translate_rid_to_vid(attr.value.aclaction.parameter.oid);
break;
case SAI_SERIALIZATION_TYPE_ACL_ACTION_DATA_OBJECT_LIST:
translate_list_rid_to_vid(attr.value.aclaction.parameter.objlist);
break;
case SAI_SERIALIZATION_TYPE_PORT_BREAKOUT:
translate_list_rid_to_vid(attr.value.portbreakout.port_list);
default:
break;
}
}
}
void translate_list_rid_to_vid(
_In_ T &element)
{
SWSS_LOG_ENTER();
for (uint32_t i = 0; i < element.count; i++)
{
element.list[i] = translate_rid_to_vid(element.list[i]);
}
}
void helperCheckPortIds()
{
SWSS_LOG_ENTER();
auto laneMap = saiGetHardwareLaneMap();
for (auto kv: laneMap)
{
sai_object_id_t portId = kv.second;
// translate will create entry if missing
// we assume here that port numbers didn't changed
// during restarts
sai_object_id_t vid = translate_rid_to_vid(portId);
sai_object_type_t objectType = sai_object_type_query(portId);
if (objectType == SAI_OBJECT_TYPE_NULL)
{
SWSS_LOG_ERROR("sai_object_type_query returned NULL type for RID %llx", portId);
exit(EXIT_FAILURE);
}
std::string strObjectType;
sai_serialize_primitive(objectType, strObjectType);
std::string strVid;
sai_serialize_primitive(vid, strVid);
std::string strKey = "ASIC_STATE:" + strObjectType + ":" + strVid;
g_redisClient->hset(strKey, "NULL", "NULL");
}
}
void test_bulk_next_hop_group_member_create()
{
SWSS_LOG_ENTER();
swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_NOTICE);
clearDB();
meta_init_db();
redis_clear_switch_ids();
auto consumerThreads = new std::thread(bulk_nhgm_consumer_worker);
swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG);
sai_status_t status;
sai_next_hop_group_api_t *sai_next_hop_group_api = NULL;
sai_switch_api_t *sai_switch_api = NULL;
sai_api_query(SAI_API_NEXT_HOP_GROUP, (void**)&sai_next_hop_group_api);
sai_api_query(SAI_API_SWITCH, (void**)&sai_switch_api);
uint32_t count = 3;
std::vector<sai_route_entry_t> routes;
std::vector<sai_attribute_t> attrs;
sai_attribute_t swattr;
swattr.id = SAI_SWITCH_ATTR_INIT_SWITCH;
swattr.value.booldata = true;
sai_object_id_t switch_id;
status = sai_switch_api->create_switch(&switch_id, 1, &swattr);
ASSERT_SUCCESS("Failed to create switch");
std::vector<std::vector<sai_attribute_t>> nhgm_attrs;
std::vector<sai_attribute_t *> nhgm_attrs_array;
std::vector<uint32_t> nhgm_attrs_count;
// next hop group
sai_object_id_t hopgroup = create_dummy_object_id(SAI_OBJECT_TYPE_NEXT_HOP_GROUP);
object_reference_insert(hopgroup);
sai_object_meta_key_t meta_key_hopgruop = { .objecttype = SAI_OBJECT_TYPE_NEXT_HOP_GROUP, .objectkey = { .key = { .object_id = hopgroup } } };
std::string hopgroup_key = sai_serialize_object_meta_key(meta_key_hopgruop);
ObjectAttrHash[hopgroup_key] = { };
sai_object_id_t hopgroup_vid = translate_rid_to_vid(hopgroup, switch_id);
for (uint32_t i = 0; i < count; ++i)
{
// next hop
sai_object_id_t hop = create_dummy_object_id(SAI_OBJECT_TYPE_NEXT_HOP);
object_reference_insert(hop);
sai_object_meta_key_t meta_key_hop = { .objecttype = SAI_OBJECT_TYPE_NEXT_HOP, .objectkey = { .key = { .object_id = hop } } };
std::string hop_key = sai_serialize_object_meta_key(meta_key_hop);
ObjectAttrHash[hop_key] = { };
sai_object_id_t hop_vid = translate_rid_to_vid(hop, switch_id);
std::vector<sai_attribute_t> list(2);
sai_attribute_t &attr1 = list[0];
sai_attribute_t &attr2 = list[1];
attr1.id = SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID;
attr1.value.oid = hopgroup_vid;
attr2.id = SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_ID;
attr2.value.oid = hop_vid;
nhgm_attrs.push_back(list);
nhgm_attrs_count.push_back(2);
}
for (size_t j = 0; j < nhgm_attrs.size(); j++)
{
nhgm_attrs_array.push_back(nhgm_attrs[j].data());
}
std::vector<sai_status_t> statuses(count);
std::vector<sai_object_id_t> object_id(count);
sai_bulk_create_next_hop_group_members(switch_id, count, nhgm_attrs_count.data(), nhgm_attrs_array.data()
, SAI_BULK_OP_TYPE_INGORE_ERROR, object_id.data(), statuses.data());
ASSERT_SUCCESS("Failed to bulk create nhgm");
for (size_t j = 0; j < statuses.size(); j++)
{
status = statuses[j];
ASSERT_SUCCESS("Failed to create nhgm # %zu", j);
}
consumerThreads->join();
delete consumerThreads;
// check the created nhgm
for (size_t i = 0; i < created_next_hop_group_member.size(); i++)
{
auto& created = created_next_hop_group_member[i];
auto& created_attrs = std::get<2>(created);
assert(created_attrs.size() == 2);
assert(created_attrs[1].value.oid == nhgm_attrs[i][1].value.oid);
}
status = sai_bulk_remove_next_hop_group_members(count, object_id.data(), SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data());
ASSERT_SUCCESS("Failed to bulk remove nhgm");
}
