void clear_local_state() { SWSS_LOG_ENTER(); SWSS_LOG_NOTICE("clearing local state"); /* * Initialize metatada database. */ meta_init_db(); /* * Reset used switch ids. */ vs_clear_switch_ids(); /* * Reset real counter id values */ vs_reset_id_counter(); }
void test_bulk_fdb_create() { SWSS_LOG_ENTER(); swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_NOTICE); clearDB(); meta_init_db(); redis_clear_switch_ids(); swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG); sai_status_t status; sai_route_api_t *sai_fdb_api = NULL; sai_switch_api_t *sai_switch_api = NULL; sai_api_query(SAI_API_FDB, (void**)&sai_fdb_api); sai_api_query(SAI_API_SWITCH, (void**)&sai_switch_api); uint32_t count = 3; std::vector<sai_fdb_entry_t> fdbs; uint32_t index = 15; 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>> fdb_attrs; std::vector<sai_attribute_t *> fdb_attrs_array; std::vector<uint32_t> fdb_attrs_count; for (uint32_t i = index; i < index + count; ++i) { // virtual router sai_object_id_t vr = create_dummy_object_id(SAI_OBJECT_TYPE_VIRTUAL_ROUTER); object_reference_insert(vr); sai_object_meta_key_t meta_key_vr = { .objecttype = SAI_OBJECT_TYPE_VIRTUAL_ROUTER, .objectkey = { .key = { .object_id = vr } } }; std::string vr_key = sai_serialize_object_meta_key(meta_key_vr); ObjectAttrHash[vr_key] = { }; // bridge port sai_object_id_t bridge_port = create_dummy_object_id(SAI_OBJECT_TYPE_BRIDGE_PORT); object_reference_insert(bridge_port); sai_object_meta_key_t meta_key_bridge_port = { .objecttype = SAI_OBJECT_TYPE_BRIDGE_PORT, .objectkey = { .key = { .object_id = bridge_port } } }; std::string bridge_port_key = sai_serialize_object_meta_key(meta_key_bridge_port); ObjectAttrHash[bridge_port_key] = { }; sai_fdb_entry_t fdb_entry; fdb_entry.switch_id = switch_id; memset(fdb_entry.mac_address, 0, sizeof(sai_mac_t)); fdb_entry.mac_address[0] = 0xD; fdb_entry.bridge_type = SAI_FDB_ENTRY_BRIDGE_TYPE_1Q; fdb_entry.vlan_id = (unsigned short)(1011 + i); fdb_entry.bridge_id = SAI_NULL_OBJECT_ID; fdbs.push_back(fdb_entry); std::vector<sai_attribute_t> attrs; sai_attribute_t attr; attr.id = SAI_FDB_ENTRY_ATTR_TYPE; attr.value.s32 = (i % 2) ? SAI_FDB_ENTRY_TYPE_DYNAMIC : SAI_FDB_ENTRY_TYPE_STATIC; attrs.push_back(attr); attr.id = SAI_FDB_ENTRY_ATTR_BRIDGE_PORT_ID; attr.value.oid = bridge_port; attrs.push_back(attr); attr.id = SAI_FDB_ENTRY_ATTR_PACKET_ACTION; attr.value.s32 = SAI_PACKET_ACTION_FORWARD; attrs.push_back(attr); fdb_attrs.push_back(attrs); fdb_attrs_count.push_back((unsigned int)attrs.size()); } for (size_t j = 0; j < fdb_attrs.size(); j++) { fdb_attrs_array.push_back(fdb_attrs[j].data()); } std::vector<sai_status_t> statuses(count); status = sai_bulk_create_fdb_entry(count, fdbs.data(), fdb_attrs_count.data(), fdb_attrs_array.data() , SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data()); ASSERT_SUCCESS("Failed to create fdb"); for (size_t j = 0; j < statuses.size(); j++) { status = statuses[j]; ASSERT_SUCCESS("Failed to create route # %zu", j); } // Remove route entry status = sai_bulk_remove_fdb_entry(count, fdbs.data(), SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data()); ASSERT_SUCCESS("Failed to bulk remove route entry"); }
void test_bulk_route_set() { SWSS_LOG_ENTER(); swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_NOTICE); clearDB(); meta_init_db(); redis_clear_switch_ids(); swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG); sai_status_t status; sai_route_api_t *sai_route_api = NULL; sai_switch_api_t *sai_switch_api = NULL; sai_api_query(SAI_API_ROUTE, (void**)&sai_route_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; uint32_t index = 15; 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>> route_attrs; std::vector<sai_attribute_t *> route_attrs_array; std::vector<uint32_t> route_attrs_count; for (uint32_t i = index; i < index + count; ++i) { sai_route_entry_t route_entry; // virtual router sai_object_id_t vr = create_dummy_object_id(SAI_OBJECT_TYPE_VIRTUAL_ROUTER); object_reference_insert(vr); sai_object_meta_key_t meta_key_vr = { .objecttype = SAI_OBJECT_TYPE_VIRTUAL_ROUTER, .objectkey = { .key = { .object_id = vr } } }; std::string vr_key = sai_serialize_object_meta_key(meta_key_vr); ObjectAttrHash[vr_key] = { }; // 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] = { }; route_entry.destination.addr_family = SAI_IP_ADDR_FAMILY_IPV4; route_entry.destination.addr.ip4 = htonl(0x0a000000 | i); route_entry.destination.mask.ip4 = htonl(0xffffffff); route_entry.vr_id = vr; route_entry.switch_id = switch_id; route_entry.destination.addr_family = SAI_IP_ADDR_FAMILY_IPV4; routes.push_back(route_entry); std::vector<sai_attribute_t> list(2); sai_attribute_t &attr1 = list[0]; sai_attribute_t &attr2 = list[1]; attr1.id = SAI_ROUTE_ENTRY_ATTR_NEXT_HOP_ID; attr1.value.oid = hop; attr2.id = SAI_ROUTE_ENTRY_ATTR_PACKET_ACTION; attr2.value.s32 = SAI_PACKET_ACTION_FORWARD; route_attrs.push_back(list); route_attrs_count.push_back(2); } for (size_t j = 0; j < route_attrs.size(); j++) { route_attrs_array.push_back(route_attrs[j].data()); } std::vector<sai_status_t> statuses(count); status = sai_bulk_create_route_entry(count, routes.data(), route_attrs_count.data(), route_attrs_array.data() , SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data()); ASSERT_SUCCESS("Failed to create route"); for (size_t j = 0; j < statuses.size(); j++) { status = statuses[j]; ASSERT_SUCCESS("Failed to create route # %zu", j); } for (uint32_t i = index; i < index + count; ++i) { sai_attribute_t attr; attr.id = SAI_ROUTE_ENTRY_ATTR_PACKET_ACTION; attr.value.s32 = SAI_PACKET_ACTION_DROP; status = sai_route_api->set_route_entry_attribute(&routes[i - index], &attr); attrs.push_back(attr); ASSERT_SUCCESS("Failed to set route"); } statuses.clear(); statuses.resize(attrs.size()); for (auto &attr: attrs) { attr.value.s32 = SAI_PACKET_ACTION_FORWARD; } status = sai_bulk_set_route_entry_attribute( count, routes.data(), attrs.data(), SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data()); ASSERT_SUCCESS("Failed to bulk set route"); for (auto s: statuses) { status = s; ASSERT_SUCCESS("Failed to bulk set route on one of the routes"); } // TODO we need to add consumer producer test here to see // if after consume we get pop we get expectd parameters // Remove route entry status = sai_bulk_remove_route_entry(count, routes.data(), SAI_BULK_OP_TYPE_INGORE_ERROR, statuses.data()); ASSERT_SUCCESS("Failed to bulk remove route entry"); }
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"); }