[syncd] Remove depreacated dependency on swss::RedisClient (sonic-net#681)

kcudnik · web-flow · commit 40439b4609e9 · 2020-10-23T22:57:52.000+02:00
diff --git a/syncd/RedisClient.cpp b/syncd/RedisClient.cpp
@@ -22,8 +22,6 @@ RedisClient::RedisClient(
 {
     SWSS_LOG_ENTER();
 
-    m_redisClient = std::make_shared<swss::RedisClient>(dbAsic.get());
-
     std::string fdbFlushLuaScript = swss::loadLuaScript("fdb_flush.lua"); // TODO script must be updated to version 2
 
     m_fdbFlushSha = swss::loadRedisScript(dbAsic.get(), fdbFlushLuaScript);
@@ -73,7 +71,7 @@ void RedisClient::clearLaneMap(
 
     auto key = getRedisLanesKey(switchVid);
 
-    m_redisClient->del(key);
+    m_dbAsic->del(key);
 }
 
 std::unordered_map<sai_uint32_t, sai_object_id_t> RedisClient::getLaneMap(
@@ -83,7 +81,7 @@ std::unordered_map<sai_uint32_t, sai_object_id_t> RedisClient::getLaneMap(
 
     auto key = getRedisLanesKey(switchVid);
 
-    auto hash = m_redisClient->hgetall(key);
+    auto hash = m_dbAsic->hgetall(key);
 
     SWSS_LOG_DEBUG("previous lanes: %lu", hash.size());
 
@@ -125,7 +123,7 @@ void RedisClient::saveLaneMap(
 
         auto key = getRedisLanesKey(switchVid);
 
-        m_redisClient->hset(key, strLane, strPortId);
+        m_dbAsic->hset(key, strLane, strPortId);
     }
 }
 
@@ -134,7 +132,7 @@ std::unordered_map<sai_object_id_t, sai_object_id_t> RedisClient::getObjectMap(
 {
     SWSS_LOG_ENTER();
 
-    auto hash = m_redisClient->hgetall(key);
+    auto hash = m_dbAsic->hgetall(key);
 
     std::unordered_map<sai_object_id_t, sai_object_id_t> map;
 
@@ -227,7 +225,7 @@ void RedisClient::setDummyAsicStateObject(
 
     std::string strKey = ASIC_STATE_TABLE + (":" + strObjectType + ":" + strVid);
 
-    m_redisClient->hset(strKey, "NULL", "NULL");
+    m_dbAsic->hset(strKey, "NULL", "NULL");
 }
 
 std::string RedisClient::getRedisColdVidsKey(
@@ -275,7 +273,7 @@ void RedisClient::saveColdBootDiscoveredVids(
 
         std::string strVid = sai_serialize_object_id(vid);
 
-        m_redisClient->hset(key, strVid, strObjectType);
+        m_dbAsic->hset(key, strVid, strObjectType);
     }
 }
 
@@ -316,7 +314,7 @@ std::shared_ptr<std::string> RedisClient::getSwitchHiddenAttribute(
 
     auto key = getRedisHiddenKey(switchVid);
 
-    return m_redisClient->hget(key, attrIdName);
+    return m_dbAsic->hget(key, attrIdName);
 }
 
 void RedisClient::saveSwitchHiddenAttribute(
@@ -330,7 +328,7 @@ void RedisClient::saveSwitchHiddenAttribute(
 
     std::string strRid = sai_serialize_object_id(objectRid);
 
-    m_redisClient->hset(key, attrIdName, strRid);
+    m_dbAsic->hset(key, attrIdName, strRid);
 }
 
 std::set<sai_object_id_t> RedisClient::getColdVids(
@@ -340,7 +338,7 @@ std::set<sai_object_id_t> RedisClient::getColdVids(
 
     auto key = getRedisColdVidsKey(switchVid);
 
-    auto hash = m_redisClient->hgetall(key);
+    auto hash = m_dbAsic->hgetall(key);
 
     /*
      * NOTE: some objects may not exists after 2nd restart, like VLAN_MEMBER or
@@ -360,7 +358,7 @@ std::set<sai_object_id_t> RedisClient::getColdVids(
          * Just make sure that vid in COLDVIDS is present in current vid2rid map
          */
 
-        auto rid = m_redisClient->hget(VIDTORID, strVid);
+        auto rid = m_dbAsic->hget(VIDTORID, strVid);
 
         if (rid == nullptr)
         {
@@ -387,7 +385,7 @@ void RedisClient::setPortLanes(
         std::string strLane = sai_serialize_number(lane);
         std::string strPortRid = sai_serialize_object_id(portRid);
 
-        m_redisClient->hset(key, strLane, strPortRid);
+        m_dbAsic->hset(key, strLane, strPortRid);
     }
 }
 
@@ -400,7 +398,7 @@ size_t RedisClient::getAsicObjectsSize(
     // go N times on every switch and it can be slow, we need to find better
     // way to do this
 
-    auto keys = m_redisClient->keys(ASIC_STATE_TABLE ":*");
+    auto keys = m_dbAsic->keys(ASIC_STATE_TABLE ":*");
 
     size_t count = 0;
 
@@ -444,7 +442,7 @@ int RedisClient::removePortFromLanesMap(
         {
             std::string strLane = sai_serialize_number(kv.first);
 
-            m_redisClient->hdel(key, strLane);
+            m_dbAsic->hdel(key, strLane);
 
             removed++;
         }
@@ -466,7 +464,7 @@ void RedisClient::removeAsicObject(
 
     SWSS_LOG_INFO("removing ASIC DB key: %s", key.c_str());
 
-    m_redisClient->del(key);
+    m_dbAsic->del(key);
 }
 
 void RedisClient::removeAsicObject(
@@ -476,7 +474,7 @@ void RedisClient::removeAsicObject(
 
     std::string key = (ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);
 
-    m_redisClient->del(key);
+    m_dbAsic->del(key);
 }
 
 void RedisClient::removeTempAsicObject(
@@ -486,7 +484,7 @@ void RedisClient::removeTempAsicObject(
 
     std::string key = (TEMP_PREFIX ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);
 
-    m_redisClient->del(key);
+    m_dbAsic->del(key);
 }
 
 void RedisClient::setAsicObject(
@@ -498,7 +496,7 @@ void RedisClient::setAsicObject(
 
     std::string key = (ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);
 
-    m_redisClient->hset(key, attr, value);
+    m_dbAsic->hset(key, attr, value);
 }
 
 void RedisClient::setTempAsicObject(
@@ -510,7 +508,7 @@ void RedisClient::setTempAsicObject(
 
     std::string key = (TEMP_PREFIX ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);
 
-    m_redisClient->hset(key, attr, value);
+    m_dbAsic->hset(key, attr, value);
 }
 
 void RedisClient::createAsicObject(
@@ -523,13 +521,13 @@ void RedisClient::createAsicObject(
 
     if (attrs.size() == 0)
     {
-        m_redisClient->hset(key, "NULL", "NULL");
+        m_dbAsic->hset(key, "NULL", "NULL");
         return;
     }
 
     for (const auto& e: attrs)
     {
-        m_redisClient->hset(key, fvField(e), fvValue(e));
+        m_dbAsic->hset(key, fvField(e), fvValue(e));
     }
 }
 
@@ -543,13 +541,13 @@ void RedisClient::createTempAsicObject(
 
     if (attrs.size() == 0)
     {
-        m_redisClient->hset(key, "NULL", "NULL");
+        m_dbAsic->hset(key, "NULL", "NULL");
         return;
     }
 
     for (const auto& e: attrs)
     {
-        m_redisClient->hset(key, fvField(e), fvValue(e));
+        m_dbAsic->hset(key, fvField(e), fvValue(e));
     }
 }
 
@@ -558,31 +556,31 @@ void RedisClient::setVidAndRidMap(
 {
     SWSS_LOG_ENTER();
 
-    m_redisClient->del(VIDTORID);
-    m_redisClient->del(RIDTOVID);
+    m_dbAsic->del(VIDTORID);
+    m_dbAsic->del(RIDTOVID);
 
     for (auto &kv: map)
     {
         std::string strVid = sai_serialize_object_id(kv.first);
         std::string strRid = sai_serialize_object_id(kv.second);
 
-        m_redisClient->hset(VIDTORID, strVid, strRid);
-        m_redisClient->hset(RIDTOVID, strRid, strVid);
+        m_dbAsic->hset(VIDTORID, strVid, strRid);
+        m_dbAsic->hset(RIDTOVID, strRid, strVid);
     }
 }
 
 std::vector<std::string> RedisClient::getAsicStateKeys() const
 {
     SWSS_LOG_ENTER();
 
-    return m_redisClient->keys(ASIC_STATE_TABLE ":*");
+    return m_dbAsic->keys(ASIC_STATE_TABLE ":*");
 }
 
 std::vector<std::string> RedisClient::getAsicStateSwitchesKeys() const
 {
     SWSS_LOG_ENTER();
 
-    return m_redisClient->keys(ASIC_STATE_TABLE ":SAI_OBJECT_TYPE_SWITCH:*");
+    return m_dbAsic->keys(ASIC_STATE_TABLE ":SAI_OBJECT_TYPE_SWITCH:*");
 }
 
 void RedisClient::removeColdVid(
@@ -592,22 +590,22 @@ void RedisClient::removeColdVid(
 
     auto strVid = sai_serialize_object_id(vid);
 
-    m_redisClient->hdel(COLDVIDS, strVid);
+    m_dbAsic->hdel(COLDVIDS, strVid);
 }
 
 std::unordered_map<std::string, std::string> RedisClient::getAttributesFromAsicKey(
         _In_ const std::string& key) const
 {
     SWSS_LOG_ENTER();
 
-    return m_redisClient->hgetall(key);
+    return m_dbAsic->hgetall(key);
 }
 
 bool RedisClient::hasNoHiddenKeysDefined() const
 {
     SWSS_LOG_ENTER();
 
-    auto keys = m_redisClient->keys(HIDDEN "*");
+    auto keys = m_dbAsic->keys(HIDDEN "*");
 
     return keys.size() == 0;
 }
@@ -621,8 +619,8 @@ void RedisClient::removeVidAndRid(
     auto strVid = sai_serialize_object_id(vid);
     auto strRid = sai_serialize_object_id(rid);
 
-    m_redisClient->hdel(VIDTORID, strVid);
-    m_redisClient->hdel(RIDTOVID, strRid);
+    m_dbAsic->hdel(VIDTORID, strVid);
+    m_dbAsic->hdel(RIDTOVID, strRid);
 }
 
 void RedisClient::insertVidAndRid(
@@ -634,8 +632,8 @@ void RedisClient::insertVidAndRid(
     auto strVid = sai_serialize_object_id(vid);
     auto strRid = sai_serialize_object_id(rid);
 
-    m_redisClient->hset(VIDTORID, strVid, strRid);
-    m_redisClient->hset(RIDTOVID, strRid, strVid);
+    m_dbAsic->hset(VIDTORID, strVid, strRid);
+    m_dbAsic->hset(RIDTOVID, strRid, strVid);
 }
 
 sai_object_id_t RedisClient::getVidForRid(
@@ -645,7 +643,7 @@ sai_object_id_t RedisClient::getVidForRid(
 
     auto strRid = sai_serialize_object_id(rid);
 
-    auto pvid = m_redisClient->hget(RIDTOVID, strRid);
+    auto pvid = m_dbAsic->hget(RIDTOVID, strRid);
 
     if (pvid == nullptr)
     {
@@ -669,7 +667,7 @@ sai_object_id_t RedisClient::getRidForVid(
 
     auto strVid = sai_serialize_object_id(vid);
 
-    auto prid = m_redisClient->hget(VIDTORID, strVid);
+    auto prid = m_dbAsic->hget(VIDTORID, strVid);
 
     if (prid == nullptr)
     {
@@ -690,23 +688,23 @@ void RedisClient::removeAsicStateTable()
 {
     SWSS_LOG_ENTER();
 
-    const auto &asicStateKeys = m_redisClient->keys(ASIC_STATE_TABLE ":*");
+    const auto &asicStateKeys = m_dbAsic->keys(ASIC_STATE_TABLE ":*");
 
     for (const auto &key: asicStateKeys)
     {
-        m_redisClient->del(key);
+        m_dbAsic->del(key);
     }
 }
 
 void RedisClient::removeTempAsicStateTable()
 {
     SWSS_LOG_ENTER();
 
-    const auto &tempAsicStateKeys = m_redisClient->keys(TEMP_PREFIX ASIC_STATE_TABLE ":*");
+    const auto &tempAsicStateKeys = m_dbAsic->keys(TEMP_PREFIX ASIC_STATE_TABLE ":*");
 
     for (const auto &key: tempAsicStateKeys)
     {
-        m_redisClient->del(key);
+        m_dbAsic->del(key);
     }
 }
 
diff --git a/syncd/RedisClient.h b/syncd/RedisClient.h
@@ -5,7 +5,6 @@ extern "C" {
 }
 
 #include "swss/table.h"
-#include "swss/redisclient.h"
 
 #include <string>
 #include <unordered_map>
@@ -166,8 +165,6 @@ namespace syncd
 
         private:
 
-            std::shared_ptr<swss::RedisClient> m_redisClient;
-
             std::shared_ptr<swss::DBConnector> m_dbAsic;
 
             std::string m_fdbFlushSha;

Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,6 @@ RedisClient::RedisClient(`
`22`	`22`	`{`
`23`	`23`	`SWSS_LOG_ENTER();`
`24`	`24`
`25`		`- m_redisClient = std::make_shared<swss::RedisClient>(dbAsic.get());`
`26`		`-`
`27`	`25`	`std::string fdbFlushLuaScript = swss::loadLuaScript("fdb_flush.lua"); // TODO script must be updated to version 2`
`28`	`26`
`29`	`27`	`m_fdbFlushSha = swss::loadRedisScript(dbAsic.get(), fdbFlushLuaScript);`
`@@ -73,7 +71,7 @@ void RedisClient::clearLaneMap(`
`73`	`71`
`74`	`72`	`auto key = getRedisLanesKey(switchVid);`
`75`	`73`
`76`		`- m_redisClient->del(key);`
	`74`	`+ m_dbAsic->del(key);`
`77`	`75`	`}`
`78`	`76`
`79`	`77`	`std::unordered_map<sai_uint32_t, sai_object_id_t> RedisClient::getLaneMap(`
`@@ -83,7 +81,7 @@ std::unordered_map<sai_uint32_t, sai_object_id_t> RedisClient::getLaneMap(`
`83`	`81`
`84`	`82`	`auto key = getRedisLanesKey(switchVid);`
`85`	`83`
`86`		`- auto hash = m_redisClient->hgetall(key);`
	`84`	`+ auto hash = m_dbAsic->hgetall(key);`
`87`	`85`
`88`	`86`	`SWSS_LOG_DEBUG("previous lanes: %lu", hash.size());`
`89`	`87`
`@@ -125,7 +123,7 @@ void RedisClient::saveLaneMap(`
`125`	`123`
`126`	`124`	`auto key = getRedisLanesKey(switchVid);`
`127`	`125`
`128`		`- m_redisClient->hset(key, strLane, strPortId);`
	`126`	`+ m_dbAsic->hset(key, strLane, strPortId);`
`129`	`127`	`}`
`130`	`128`	`}`
`131`	`129`
`@@ -134,7 +132,7 @@ std::unordered_map<sai_object_id_t, sai_object_id_t> RedisClient::getObjectMap(`
`134`	`132`	`{`
`135`	`133`	`SWSS_LOG_ENTER();`
`136`	`134`
`137`		`- auto hash = m_redisClient->hgetall(key);`
	`135`	`+ auto hash = m_dbAsic->hgetall(key);`
`138`	`136`
`139`	`137`	`std::unordered_map<sai_object_id_t, sai_object_id_t> map;`
`140`	`138`
`@@ -227,7 +225,7 @@ void RedisClient::setDummyAsicStateObject(`
`227`	`225`
`228`	`226`	`std::string strKey = ASIC_STATE_TABLE + (":" + strObjectType + ":" + strVid);`
`229`	`227`
`230`		`- m_redisClient->hset(strKey, "NULL", "NULL");`
	`228`	`+ m_dbAsic->hset(strKey, "NULL", "NULL");`
`231`	`229`	`}`
`232`	`230`
`233`	`231`	`std::string RedisClient::getRedisColdVidsKey(`
`@@ -275,7 +273,7 @@ void RedisClient::saveColdBootDiscoveredVids(`
`275`	`273`
`276`	`274`	`std::string strVid = sai_serialize_object_id(vid);`
`277`	`275`
`278`		`- m_redisClient->hset(key, strVid, strObjectType);`
	`276`	`+ m_dbAsic->hset(key, strVid, strObjectType);`
`279`	`277`	`}`
`280`	`278`	`}`
`281`	`279`
`@@ -316,7 +314,7 @@ std::shared_ptr<std::string> RedisClient::getSwitchHiddenAttribute(`
`316`	`314`
`317`	`315`	`auto key = getRedisHiddenKey(switchVid);`
`318`	`316`
`319`		`- return m_redisClient->hget(key, attrIdName);`
	`317`	`+ return m_dbAsic->hget(key, attrIdName);`
`320`	`318`	`}`
`321`	`319`
`322`	`320`	`void RedisClient::saveSwitchHiddenAttribute(`
`@@ -330,7 +328,7 @@ void RedisClient::saveSwitchHiddenAttribute(`
`330`	`328`
`331`	`329`	`std::string strRid = sai_serialize_object_id(objectRid);`
`332`	`330`
`333`		`- m_redisClient->hset(key, attrIdName, strRid);`
	`331`	`+ m_dbAsic->hset(key, attrIdName, strRid);`
`334`	`332`	`}`
`335`	`333`
`336`	`334`	`std::set<sai_object_id_t> RedisClient::getColdVids(`
`@@ -340,7 +338,7 @@ std::set<sai_object_id_t> RedisClient::getColdVids(`
`340`	`338`
`341`	`339`	`auto key = getRedisColdVidsKey(switchVid);`
`342`	`340`
`343`		`- auto hash = m_redisClient->hgetall(key);`
	`341`	`+ auto hash = m_dbAsic->hgetall(key);`
`344`	`342`
`345`	`343`	`/*`
`346`	`344`	`* NOTE: some objects may not exists after 2nd restart, like VLAN_MEMBER or`
`@@ -360,7 +358,7 @@ std::set<sai_object_id_t> RedisClient::getColdVids(`
`360`	`358`	`* Just make sure that vid in COLDVIDS is present in current vid2rid map`
`361`	`359`	`*/`
`362`	`360`
`363`		`- auto rid = m_redisClient->hget(VIDTORID, strVid);`
	`361`	`+ auto rid = m_dbAsic->hget(VIDTORID, strVid);`
`364`	`362`
`365`	`363`	`if (rid == nullptr)`
`366`	`364`	`{`
`@@ -387,7 +385,7 @@ void RedisClient::setPortLanes(`
`387`	`385`	`std::string strLane = sai_serialize_number(lane);`
`388`	`386`	`std::string strPortRid = sai_serialize_object_id(portRid);`
`389`	`387`
`390`		`- m_redisClient->hset(key, strLane, strPortRid);`
	`388`	`+ m_dbAsic->hset(key, strLane, strPortRid);`
`391`	`389`	`}`
`392`	`390`	`}`
`393`	`391`
`@@ -400,7 +398,7 @@ size_t RedisClient::getAsicObjectsSize(`
`400`	`398`	`// go N times on every switch and it can be slow, we need to find better`
`401`	`399`	`// way to do this`
`402`	`400`
`403`		`- auto keys = m_redisClient->keys(ASIC_STATE_TABLE ":*");`
	`401`	`+ auto keys = m_dbAsic->keys(ASIC_STATE_TABLE ":*");`
`404`	`402`
`405`	`403`	`size_t count = 0;`
`406`	`404`
`@@ -444,7 +442,7 @@ int RedisClient::removePortFromLanesMap(`
`444`	`442`	`{`
`445`	`443`	`std::string strLane = sai_serialize_number(kv.first);`
`446`	`444`
`447`		`- m_redisClient->hdel(key, strLane);`
	`445`	`+ m_dbAsic->hdel(key, strLane);`
`448`	`446`
`449`	`447`	`removed++;`
`450`	`448`	`}`
`@@ -466,7 +464,7 @@ void RedisClient::removeAsicObject(`
`466`	`464`
`467`	`465`	`SWSS_LOG_INFO("removing ASIC DB key: %s", key.c_str());`
`468`	`466`
`469`		`- m_redisClient->del(key);`
	`467`	`+ m_dbAsic->del(key);`
`470`	`468`	`}`
`471`	`469`
`472`	`470`	`void RedisClient::removeAsicObject(`
`@@ -476,7 +474,7 @@ void RedisClient::removeAsicObject(`
`476`	`474`
`477`	`475`	`std::string key = (ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);`
`478`	`476`
`479`		`- m_redisClient->del(key);`
	`477`	`+ m_dbAsic->del(key);`
`480`	`478`	`}`
`481`	`479`
`482`	`480`	`void RedisClient::removeTempAsicObject(`
`@@ -486,7 +484,7 @@ void RedisClient::removeTempAsicObject(`
`486`	`484`
`487`	`485`	`std::string key = (TEMP_PREFIX ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);`
`488`	`486`
`489`		`- m_redisClient->del(key);`
	`487`	`+ m_dbAsic->del(key);`
`490`	`488`	`}`
`491`	`489`
`492`	`490`	`void RedisClient::setAsicObject(`
`@@ -498,7 +496,7 @@ void RedisClient::setAsicObject(`
`498`	`496`
`499`	`497`	`std::string key = (ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);`
`500`	`498`
`501`		`- m_redisClient->hset(key, attr, value);`
	`499`	`+ m_dbAsic->hset(key, attr, value);`
`502`	`500`	`}`
`503`	`501`
`504`	`502`	`void RedisClient::setTempAsicObject(`
`@@ -510,7 +508,7 @@ void RedisClient::setTempAsicObject(`
`510`	`508`
`511`	`509`	`std::string key = (TEMP_PREFIX ASIC_STATE_TABLE ":") + sai_serialize_object_meta_key(metaKey);`
`512`	`510`
`513`		`- m_redisClient->hset(key, attr, value);`
	`511`	`+ m_dbAsic->hset(key, attr, value);`
`514`	`512`	`}`
`515`	`513`
`516`	`514`	`void RedisClient::createAsicObject(`
`@@ -523,13 +521,13 @@ void RedisClient::createAsicObject(`
`523`	`521`
`524`	`522`	`if (attrs.size() == 0)`
`525`	`523`	`{`
`526`		`- m_redisClient->hset(key, "NULL", "NULL");`
	`524`	`+ m_dbAsic->hset(key, "NULL", "NULL");`
`527`	`525`	`return;`
`528`	`526`	`}`
`529`	`527`
`530`	`528`	`for (const auto& e: attrs)`
`531`	`529`	`{`
`532`		`- m_redisClient->hset(key, fvField(e), fvValue(e));`
	`530`	`+ m_dbAsic->hset(key, fvField(e), fvValue(e));`
`533`	`531`	`}`
`534`	`532`	`}`
`535`	`533`
`@@ -543,13 +541,13 @@ void RedisClient::createTempAsicObject(`
`543`	`541`
`544`	`542`	`if (attrs.size() == 0)`
`545`	`543`	`{`
`546`		`- m_redisClient->hset(key, "NULL", "NULL");`
	`544`	`+ m_dbAsic->hset(key, "NULL", "NULL");`
`547`	`545`	`return;`
`548`	`546`	`}`
`549`	`547`
`550`	`548`	`for (const auto& e: attrs)`
`551`	`549`	`{`
`552`		`- m_redisClient->hset(key, fvField(e), fvValue(e));`
	`550`	`+ m_dbAsic->hset(key, fvField(e), fvValue(e));`
`553`	`551`	`}`
`554`	`552`	`}`
`555`	`553`
`@@ -558,31 +556,31 @@ void RedisClient::setVidAndRidMap(`
`558`	`556`	`{`
`559`	`557`	`SWSS_LOG_ENTER();`
`560`	`558`
`561`		`- m_redisClient->del(VIDTORID);`
`562`		`- m_redisClient->del(RIDTOVID);`
	`559`	`+ m_dbAsic->del(VIDTORID);`
	`560`	`+ m_dbAsic->del(RIDTOVID);`
`563`	`561`
`564`	`562`	`for (auto &kv: map)`
`565`	`563`	`{`
`566`	`564`	`std::string strVid = sai_serialize_object_id(kv.first);`
`567`	`565`	`std::string strRid = sai_serialize_object_id(kv.second);`
`568`	`566`
`569`		`- m_redisClient->hset(VIDTORID, strVid, strRid);`
`570`		`- m_redisClient->hset(RIDTOVID, strRid, strVid);`
	`567`	`+ m_dbAsic->hset(VIDTORID, strVid, strRid);`
	`568`	`+ m_dbAsic->hset(RIDTOVID, strRid, strVid);`
`571`	`569`	`}`
`572`	`570`	`}`
`573`	`571`
`574`	`572`	`std::vector<std::string> RedisClient::getAsicStateKeys() const`
`575`	`573`	`{`
`576`	`574`	`SWSS_LOG_ENTER();`
`577`	`575`
`578`		`- return m_redisClient->keys(ASIC_STATE_TABLE ":*");`
	`576`	`+ return m_dbAsic->keys(ASIC_STATE_TABLE ":*");`
`579`	`577`	`}`
`580`	`578`
`581`	`579`	`std::vector<std::string> RedisClient::getAsicStateSwitchesKeys() const`
`582`	`580`	`{`
`583`	`581`	`SWSS_LOG_ENTER();`
`584`	`582`
`585`		`- return m_redisClient->keys(ASIC_STATE_TABLE ":SAI_OBJECT_TYPE_SWITCH:*");`
	`583`	`+ return m_dbAsic->keys(ASIC_STATE_TABLE ":SAI_OBJECT_TYPE_SWITCH:*");`
`586`	`584`	`}`
`587`	`585`
`588`	`586`	`void RedisClient::removeColdVid(`
`@@ -592,22 +590,22 @@ void RedisClient::removeColdVid(`
`592`	`590`
`593`	`591`	`auto strVid = sai_serialize_object_id(vid);`
`594`	`592`
`595`		`- m_redisClient->hdel(COLDVIDS, strVid);`
	`593`	`+ m_dbAsic->hdel(COLDVIDS, strVid);`
`596`	`594`	`}`
`597`	`595`
`598`	`596`	`std::unordered_map<std::string, std::string> RedisClient::getAttributesFromAsicKey(`
`599`	`597`	`_In_ const std::string& key) const`
`600`	`598`	`{`
`601`	`599`	`SWSS_LOG_ENTER();`
`602`	`600`
`603`		`- return m_redisClient->hgetall(key);`
	`601`	`+ return m_dbAsic->hgetall(key);`
`604`	`602`	`}`
`605`	`603`
`606`	`604`	`bool RedisClient::hasNoHiddenKeysDefined() const`
`607`	`605`	`{`
`608`	`606`	`SWSS_LOG_ENTER();`
`609`	`607`
`610`		`- auto keys = m_redisClient->keys(HIDDEN "*");`
	`608`	`+ auto keys = m_dbAsic->keys(HIDDEN "*");`
`611`	`609`
`612`	`610`	`return keys.size() == 0;`
`613`	`611`	`}`
`@@ -621,8 +619,8 @@ void RedisClient::removeVidAndRid(`
`621`	`619`	`auto strVid = sai_serialize_object_id(vid);`
`622`	`620`	`auto strRid = sai_serialize_object_id(rid);`
`623`	`621`
`624`		`- m_redisClient->hdel(VIDTORID, strVid);`
`625`		`- m_redisClient->hdel(RIDTOVID, strRid);`
	`622`	`+ m_dbAsic->hdel(VIDTORID, strVid);`
	`623`	`+ m_dbAsic->hdel(RIDTOVID, strRid);`
`626`	`624`	`}`
`627`	`625`
`628`	`626`	`void RedisClient::insertVidAndRid(`
`@@ -634,8 +632,8 @@ void RedisClient::insertVidAndRid(`
`634`	`632`	`auto strVid = sai_serialize_object_id(vid);`
`635`	`633`	`auto strRid = sai_serialize_object_id(rid);`
`636`	`634`
`637`		`- m_redisClient->hset(VIDTORID, strVid, strRid);`
`638`		`- m_redisClient->hset(RIDTOVID, strRid, strVid);`
	`635`	`+ m_dbAsic->hset(VIDTORID, strVid, strRid);`
	`636`	`+ m_dbAsic->hset(RIDTOVID, strRid, strVid);`
`639`	`637`	`}`
`640`	`638`
`641`	`639`	`sai_object_id_t RedisClient::getVidForRid(`
`@@ -645,7 +643,7 @@ sai_object_id_t RedisClient::getVidForRid(`
`645`	`643`
`646`	`644`	`auto strRid = sai_serialize_object_id(rid);`
`647`	`645`
`648`		`- auto pvid = m_redisClient->hget(RIDTOVID, strRid);`
	`646`	`+ auto pvid = m_dbAsic->hget(RIDTOVID, strRid);`
`649`	`647`
`650`	`648`	`if (pvid == nullptr)`
`651`	`649`	`{`
`@@ -669,7 +667,7 @@ sai_object_id_t RedisClient::getRidForVid(`
`669`	`667`
`670`	`668`	`auto strVid = sai_serialize_object_id(vid);`
`671`	`669`
`672`		`- auto prid = m_redisClient->hget(VIDTORID, strVid);`
	`670`	`+ auto prid = m_dbAsic->hget(VIDTORID, strVid);`
`673`	`671`
`674`	`672`	`if (prid == nullptr)`
`675`	`673`	`{`
`@@ -690,23 +688,23 @@ void RedisClient::removeAsicStateTable()`
`690`	`688`	`{`
`691`	`689`	`SWSS_LOG_ENTER();`
`692`	`690`
`693`		`- const auto &asicStateKeys = m_redisClient->keys(ASIC_STATE_TABLE ":*");`
	`691`	`+ const auto &asicStateKeys = m_dbAsic->keys(ASIC_STATE_TABLE ":*");`
`694`	`692`
`695`	`693`	`for (const auto &key: asicStateKeys)`
`696`	`694`	`{`
`697`		`- m_redisClient->del(key);`
	`695`	`+ m_dbAsic->del(key);`
`698`	`696`	`}`
`699`	`697`	`}`
`700`	`698`
`701`	`699`	`void RedisClient::removeTempAsicStateTable()`
`702`	`700`	`{`
`703`	`701`	`SWSS_LOG_ENTER();`
`704`	`702`
`705`		`- const auto &tempAsicStateKeys = m_redisClient->keys(TEMP_PREFIX ASIC_STATE_TABLE ":*");`
	`703`	`+ const auto &tempAsicStateKeys = m_dbAsic->keys(TEMP_PREFIX ASIC_STATE_TABLE ":*");`
`706`	`704`
`707`	`705`	`for (const auto &key: tempAsicStateKeys)`
`708`	`706`	`{`
`709`		`- m_redisClient->del(key);`
	`707`	`+ m_dbAsic->del(key);`
`710`	`708`	`}`
`711`	`709`	`}`
`712`	`710`