objsearch_pi::~objsearch_pi ( void )
{
clearDB(m_db);
delete _img_objsearch_pi;
delete _img_objsearch;
}
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");
}
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");
}
bool zmodifyer::update( UStringVector & file_names, UStringVector & commandStrings, wchar_t const * password )
{
if( file_names.IsEmpty() )
return false;
// 프로그래스 뷰 사용안함
commandStrings.Add( L"-BD" );
// 솔리드 압축 사용 안함
commandStrings.Add( L"-MS=OFF" );
// 압축 방식 lzma2
commandStrings.Add( L"-M0=LZMA2" );
// multi thread
commandStrings.Add( L"-MMT=+" );
if( password && wcslen(password) )
{
UString pw( L"-P" );
commandStrings.Add( (pw + ( password ? password : L"") ) );
}
commandStrings.Add( file_name_ );
for( int i=0; i<file_names.Size(); ++i )
commandStrings.Add( file_names[i] );
// 파싱된 커맨드라인 정보로 options 셋팅 ------------
CArchiveCommandLineOptions options;
OptionSetting( commandStrings, options );
options.OverwriteMode = NExtract::NOverwriteMode::kWithoutPrompt; // 덮어쓰기 할때 묻지마라.
options.YesToAll = true;
//------------
// 압축파일 형식 인덱스 추출.
CIntVector formatIndices;
if (!codecs_->FindFormatForArchiveType(options.ArcType, formatIndices))
{
throw kUnsupportedArcTypeMessage;
}
CUpdateOptions &uo = options.UpdateOptions;
if (uo.SfxMode && uo.SfxModule.IsEmpty())
uo.SfxModule = kDefaultSfxModule;
COpenCallbackConsole openCallback;
openCallback.OutStream = &outStream_;
#ifndef _NO_CRYPTO
bool passwordIsDefined =
options.PasswordEnabled && !options.Password.IsEmpty();
openCallback.PasswordIsDefined = passwordIsDefined;
openCallback.Password = options.Password;
#endif
CUpdateCallbackConsole callback;
callback.EnablePercents = options.EnablePercents;
#ifndef _NO_CRYPTO
callback.PasswordIsDefined = passwordIsDefined;
callback.AskPassword = options.PasswordEnabled && options.Password.IsEmpty();
callback.Password = options.Password;
#endif
callback.StdOutMode = uo.StdOutMode;
callback.Init(&outStream_);
CUpdateErrorInfo errorInfo;
if (!uo.Init(codecs_, formatIndices, options.ArchiveName))
throw kUnsupportedArcTypeMessage;
HRESULT result = UpdateArchive(codecs_,
options.WildcardCensor, uo,
errorInfo, &openCallback, &callback, zdb_);
clearDB();
return result == S_OK;
}
