Replace RedisClient with DBConnector (sonic-net#1439)

qiluo-msft · web-flow · commit b4938a5519d6 · 2020-09-18T00:21:12.000-07:00
After this PR: sonic-net/sonic-swss-common#382
diff --git a/mclagsyncd/mclaglink.cpp b/mclagsyncd/mclaglink.cpp
@@ -38,7 +38,7 @@ using namespace std;
 void MclagLink::getOidToPortNameMap(std::unordered_map<std::string, std:: string> & port_map)
 {
     std::unordered_map<std::string, std:: string>::iterator it;
-    auto hash = p_redisClient_to_counters->hgetall("COUNTERS_PORT_NAME_MAP");
+    auto hash = p_counters_db->hgetall("COUNTERS_PORT_NAME_MAP");
 
     for (it = hash.begin(); it != hash.end(); ++it)
         port_map.insert(pair<string, string>(it->second, it->first));
@@ -53,14 +53,14 @@ void MclagLink::getBridgePortIdToAttrPortIdMap(std::map<std::string, std:: strin
 
     std::unordered_map<string, string>::iterator attr_port_id;
 
-    auto keys = p_redisClient_to_asic->keys("ASIC_STATE:SAI_OBJECT_TYPE_BRIDGE_PORT:*");
+    auto keys = p_asic_db->keys("ASIC_STATE:SAI_OBJECT_TYPE_BRIDGE_PORT:*");
 
     for (auto& key : keys)
     {
         pos1 = key.find("oid:", 0);
         bridge_port_id = key.substr(pos1);
 
-        auto hash = p_redisClient_to_asic->hgetall(key);
+        auto hash = p_asic_db->hgetall(key);
         attr_port_id = hash.find("SAI_BRIDGE_PORT_ATTR_PORT_ID");
         if (attr_port_id == hash.end())
         {
@@ -81,7 +81,7 @@ void MclagLink::getVidByBvid(std::string &bvid, std::string &vlanid)
     std::string pre = "ASIC_STATE:SAI_OBJECT_TYPE_VLAN:";
     std::string key = pre + bvid;
 
-    auto hash = p_redisClient_to_asic->hgetall(key.c_str());
+    auto hash = p_asic_db->hgetall(key.c_str());
 
     attr_vlan_id = hash.find("SAI_VLAN_ATTR_VLAN_ID");
     if (attr_vlan_id == hash.end())
@@ -109,7 +109,7 @@ void MclagLink::getFdbSet(std::set<mclag_fdb> *fdb_set)
     std::map<std::string, std::string>::iterator brPortId_to_attrPortId_it;
     std::unordered_map<std::string, std::string>::iterator oid_to_portName_it;
 
-    auto keys = p_redisClient_to_asic->keys("ASIC_STATE:SAI_OBJECT_TYPE_FDB_ENTRY:*");
+    auto keys = p_asic_db->keys("ASIC_STATE:SAI_OBJECT_TYPE_FDB_ENTRY:*");
 
     for (auto& key : keys)
     {
@@ -136,7 +136,7 @@ void MclagLink::getFdbSet(std::set<mclag_fdb> *fdb_set)
         mac = key.substr(pos1, pos2 - pos1 + 1);
 
         /*get type*/
-        auto hash = p_redisClient_to_asic->hgetall(key);
+        auto hash = p_asic_db->hgetall(key);
         type_it = hash.find("SAI_FDB_ENTRY_ATTR_TYPE");
         if (type_it == hash.end())
         {
diff --git a/mclagsyncd/mclaglink.h b/mclagsyncd/mclaglink.h
@@ -102,8 +102,8 @@ class MclagLink : public Selectable {
     ProducerStateTable *p_acl_table_tbl;
     ProducerStateTable *p_acl_rule_tbl;
     DBConnector *p_appl_db;
-    RedisClient *p_redisClient_to_asic;/*redis client access to ASIC_DB*/
-    RedisClient *p_redisClient_to_counters;/*redis client access to COUNTERS_DB*/
+    DBConnector *p_asic_db; /*redis client access to ASIC_DB*/
+    DBConnector *p_counters_db; /*redis client access to COUNTERS_DB*/
     std::set <mclag_fdb> *p_old_fdb;
 
     MclagLink(uint16_t port = MCLAG_DEFAULT_PORT);
diff --git a/mclagsyncd/mclagsyncd.cpp b/mclagsyncd/mclagsyncd.cpp
@@ -41,8 +41,6 @@ int main(int argc, char **argv)
     ProducerStateTable fdb_tbl(&appl_db, APP_FDB_TABLE_NAME);
     ProducerStateTable acl_table_tbl(&appl_db, APP_ACL_TABLE_TABLE_NAME);
     ProducerStateTable acl_rule_tbl(&appl_db, APP_ACL_RULE_TABLE_NAME);
-    RedisClient redisClient_to_asicDb(&asic_db);
-    RedisClient redisClient_to_countersDb(&counters_db);
     map <string, string> isolate;
     RedisPipeline pipeline(&appl_db);
     set <mclag_fdb> old_fdb;
@@ -62,8 +60,8 @@ int main(int argc, char **argv)
             mclag.p_acl_table_tbl = &acl_table_tbl;
             mclag.p_acl_rule_tbl = &acl_rule_tbl;
             mclag.p_appl_db = &appl_db;
-            mclag.p_redisClient_to_asic = &redisClient_to_asicDb;
-            mclag.p_redisClient_to_counters = &redisClient_to_countersDb;
+            mclag.p_asic_db = &asic_db;
+            mclag.p_counters_db = &counters_db;
             mclag.p_old_fdb = &old_fdb;
 
             cout << "Waiting for connection..." << endl;
diff --git a/orchagent/bufferorch.cpp b/orchagent/bufferorch.cpp
@@ -39,8 +39,7 @@ BufferOrch::BufferOrch(DBConnector *db, vector<string> &tableNames) :
     m_flexCounterDb(new DBConnector("FLEX_COUNTER_DB", 0)),
     m_flexCounterTable(new ProducerTable(m_flexCounterDb.get(), FLEX_COUNTER_TABLE)),
     m_flexCounterGroupTable(new ProducerTable(m_flexCounterDb.get(), FLEX_COUNTER_GROUP_TABLE)),
-    m_countersDb(new DBConnector("COUNTERS_DB", 0)),
-    m_countersDbRedisClient(m_countersDb.get())
+    m_countersDb(new DBConnector("COUNTERS_DB", 0))
 {
     SWSS_LOG_ENTER();
     initTableHandlers();
@@ -358,7 +357,7 @@ task_process_status BufferOrch::processBufferPool(Consumer &consumer)
             // Specifically, we push the buffer pool name to oid mapping upon the creation of the oid
             // In pg and queue case, this mapping installment is deferred to FlexCounterOrch at a reception of field
             // "FLEX_COUNTER_STATUS"
-            m_countersDbRedisClient.hset(COUNTERS_BUFFER_POOL_NAME_MAP, object_name, sai_serialize_object_id(sai_object));
+            m_countersDb->hset(COUNTERS_BUFFER_POOL_NAME_MAP, object_name, sai_serialize_object_id(sai_object));
         }
     }
     else if (op == DEL_COMMAND)
@@ -372,7 +371,7 @@ task_process_status BufferOrch::processBufferPool(Consumer &consumer)
         SWSS_LOG_NOTICE("Removed buffer pool %s with type %s", object_name.c_str(), map_type_name.c_str());
         auto it_to_delete = (m_buffer_type_maps[map_type_name])->find(object_name);
         (m_buffer_type_maps[map_type_name])->erase(it_to_delete);
-        m_countersDbRedisClient.hdel(COUNTERS_BUFFER_POOL_NAME_MAP, object_name);
+        m_countersDb->hdel(COUNTERS_BUFFER_POOL_NAME_MAP, object_name);
     }
     else
     {
diff --git a/orchagent/bufferorch.h b/orchagent/bufferorch.h
@@ -64,7 +64,6 @@ class BufferOrch : public Orch
     unique_ptr<ProducerTable> m_flexCounterTable;
 
     unique_ptr<DBConnector> m_countersDb;
-    RedisClient m_countersDbRedisClient;
 
     bool m_isBufferPoolWatermarkCounterIdListGenerated = false;
 };
diff --git a/orchagent/countercheckorch.cpp b/orchagent/countercheckorch.cpp
@@ -193,13 +193,12 @@ QueueMcCounters CounterCheckOrch::getQueueMcCounters(
 
     vector<FieldValueTuple> fieldValues;
     QueueMcCounters counters;
-    RedisClient redisClient(m_countersDb.get());
 
     for (uint8_t prio = 0; prio < port.m_queue_ids.size(); prio++)
     {
         sai_object_id_t queueId = port.m_queue_ids[prio];
         auto queueIdStr = sai_serialize_object_id(queueId);
-        auto queueType = redisClient.hget(COUNTERS_QUEUE_TYPE_MAP, queueIdStr);
+        auto queueType = m_countersDb->hget(COUNTERS_QUEUE_TYPE_MAP, queueIdStr);
 
         if (queueType.get() == nullptr || *queueType != "SAI_QUEUE_TYPE_MULTICAST" || !m_countersTable->get(queueIdStr, fieldValues))
         {
diff --git a/orchagent/pfcwdorch.cpp b/orchagent/pfcwdorch.cpp
@@ -364,9 +364,8 @@ void PfcWdSwOrch<DropHandler, ForwardHandler>::disableBigRedSwitchMode()
         }
 
         auto queueId = entry.first;
-        RedisClient redisClient(this->getCountersDb().get());
         string countersKey = this->getCountersTable()->getTableName() + this->getCountersTable()->getTableNameSeparator() + sai_serialize_object_id(queueId);
-        redisClient.hdel(countersKey, "BIG_RED_SWITCH_MODE");
+        this->getCountersDb()->hdel(countersKey, "BIG_RED_SWITCH_MODE");
     }
 
     m_brsEntryMap.clear();
@@ -633,9 +632,8 @@ void PfcWdSwOrch<DropHandler, ForwardHandler>::unregisterFromWdDb(const Port& po
         m_entryMap.erase(queueId);
 
         // Clean up
-        RedisClient redisClient(this->getCountersDb().get());
         string countersKey = this->getCountersTable()->getTableName() + this->getCountersTable()->getTableNameSeparator() + sai_serialize_object_id(queueId);
-        redisClient.hdel(countersKey, {"PFC_WD_DETECTION_TIME", "PFC_WD_RESTORATION_TIME", "PFC_WD_ACTION", "PFC_WD_STATUS"});
+        this->getCountersDb()->hdel(countersKey, {"PFC_WD_DETECTION_TIME", "PFC_WD_RESTORATION_TIME", "PFC_WD_ACTION", "PFC_WD_STATUS"});
     }
 
 }
@@ -657,8 +655,7 @@ PfcWdSwOrch<DropHandler, ForwardHandler>::PfcWdSwOrch(
     c_queueAttrIds(queueAttrIds),
     m_pollInterval(pollInterval),
     m_applDb(make_shared<DBConnector>("APPL_DB", 0)),
-    m_applTable(make_shared<Table>(m_applDb.get(), APP_PFC_WD_TABLE_NAME "_INSTORM")),
-    m_applDbRedisClient(m_applDb.get())
+    m_applTable(make_shared<Table>(m_applDb.get(), APP_PFC_WD_TABLE_NAME "_INSTORM"))
 {
     SWSS_LOG_ENTER();
 
@@ -934,7 +931,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string
                 entry->second.handler->initCounters();
                 // Log storm event to APPL_DB for warm-reboot purpose
                 string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;
-                m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
+                m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
             }
         }
         else if (entry->second.action == PfcWdAction::PFC_WD_ACTION_DROP)
@@ -956,7 +953,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string
                 entry->second.handler->initCounters();
                 // Log storm event to APPL_DB for warm-reboot purpose
                 string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;
-                m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
+                m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
             }
         }
         else if (entry->second.action == PfcWdAction::PFC_WD_ACTION_FORWARD)
@@ -978,7 +975,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string
                 entry->second.handler->initCounters();
                 // Log storm event to APPL_DB for warm-reboot purpose
                 string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;
-                m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
+                m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);
             }
         }
         else
@@ -1002,7 +999,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string
             entry->second.handler = nullptr;
             // Remove storm status in APPL_DB for warm-reboot purpose
             string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;
-            m_applDbRedisClient.hdel(key, to_string(entry->second.index));
+            m_applDb->hdel(key, to_string(entry->second.index));
         }
     }
     else
@@ -1019,8 +1016,6 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::bake()
 {
     // clean all *_last and *_LEFT fields in COUNTERS_TABLE
     // to allow warm-reboot pfc detect & restore state machine to enter the same init state as cold-reboot
-    RedisClient redisClient(this->getCountersDb().get());
-
     vector<string> cKeys;
     this->getCountersTable()->getKeys(cKeys);
     for (const auto &key : cKeys)
@@ -1037,7 +1032,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::bake()
         }
         if (!wLasts.empty())
         {
-            redisClient.hdel(
+            this->getCountersDb()->hdel(
                 this->getCountersTable()->getTableName()
                 + this->getCountersTable()->getTableNameSeparator()
                 + key,
diff --git a/orchagent/pfcwdorch.h b/orchagent/pfcwdorch.h
@@ -135,8 +135,6 @@ class PfcWdSwOrch: public PfcWdOrch<DropHandler, ForwardHandler>
     shared_ptr<DBConnector> m_applDb = nullptr;
     // Track queues in storm
     shared_ptr<Table> m_applTable = nullptr;
-    // used for hset and hdel
-    RedisClient m_applDbRedisClient;
 };
 
 #endif
diff --git a/orchagent/portsorch.cpp b/orchagent/portsorch.cpp
@@ -1894,8 +1894,7 @@ void PortsOrch::deInitPort(string alias, sai_object_id_t port_id)
     port_stat_manager.clearCounterIdList(p.m_port_id);
 
     /* remove port name map from counter table */
-    RedisClient redisClient(m_counter_db.get());
-    redisClient.hdel(COUNTERS_PORT_NAME_MAP, alias);
+    m_counter_db->hdel(COUNTERS_PORT_NAME_MAP, alias);
 
     m_portList[alias].m_init = false;
     SWSS_LOG_NOTICE("De-Initialized port %s", alias.c_str());

Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,7 @@ BufferOrch::BufferOrch(DBConnector *db, vector<string> &tableNames) :`
`39`	`39`	`m_flexCounterDb(new DBConnector("FLEX_COUNTER_DB", 0)),`
`40`	`40`	`m_flexCounterTable(new ProducerTable(m_flexCounterDb.get(), FLEX_COUNTER_TABLE)),`
`41`	`41`	`m_flexCounterGroupTable(new ProducerTable(m_flexCounterDb.get(), FLEX_COUNTER_GROUP_TABLE)),`
`42`		`- m_countersDb(new DBConnector("COUNTERS_DB", 0)),`
`43`		`- m_countersDbRedisClient(m_countersDb.get())`
	`42`	`+ m_countersDb(new DBConnector("COUNTERS_DB", 0))`
`44`	`43`	`{`
`45`	`44`	`SWSS_LOG_ENTER();`
`46`	`45`	`initTableHandlers();`
`@@ -358,7 +357,7 @@ task_process_status BufferOrch::processBufferPool(Consumer &consumer)`
`358`	`357`	`// Specifically, we push the buffer pool name to oid mapping upon the creation of the oid`
`359`	`358`	`// In pg and queue case, this mapping installment is deferred to FlexCounterOrch at a reception of field`
`360`	`359`	`// "FLEX_COUNTER_STATUS"`
`361`		`- m_countersDbRedisClient.hset(COUNTERS_BUFFER_POOL_NAME_MAP, object_name, sai_serialize_object_id(sai_object));`
	`360`	`+ m_countersDb->hset(COUNTERS_BUFFER_POOL_NAME_MAP, object_name, sai_serialize_object_id(sai_object));`
`362`	`361`	`}`
`363`	`362`	`}`
`364`	`363`	`else if (op == DEL_COMMAND)`
`@@ -372,7 +371,7 @@ task_process_status BufferOrch::processBufferPool(Consumer &consumer)`
`372`	`371`	`SWSS_LOG_NOTICE("Removed buffer pool %s with type %s", object_name.c_str(), map_type_name.c_str());`
`373`	`372`	`auto it_to_delete = (m_buffer_type_maps[map_type_name])->find(object_name);`
`374`	`373`	`(m_buffer_type_maps[map_type_name])->erase(it_to_delete);`
`375`		`- m_countersDbRedisClient.hdel(COUNTERS_BUFFER_POOL_NAME_MAP, object_name);`
	`374`	`+ m_countersDb->hdel(COUNTERS_BUFFER_POOL_NAME_MAP, object_name);`
`376`	`375`	`}`
`377`	`376`	`else`
`378`	`377`	`{`
Original file line number	Diff line number	Diff line change
`@@ -193,13 +193,12 @@ QueueMcCounters CounterCheckOrch::getQueueMcCounters(`
`193`	`193`
`194`	`194`	`vector<FieldValueTuple> fieldValues;`
`195`	`195`	`QueueMcCounters counters;`
`196`		`- RedisClient redisClient(m_countersDb.get());`
`197`	`196`
`198`	`197`	`for (uint8_t prio = 0; prio < port.m_queue_ids.size(); prio++)`
`199`	`198`	`{`
`200`	`199`	`sai_object_id_t queueId = port.m_queue_ids[prio];`
`201`	`200`	`auto queueIdStr = sai_serialize_object_id(queueId);`
`202`		`- auto queueType = redisClient.hget(COUNTERS_QUEUE_TYPE_MAP, queueIdStr);`
	`201`	`+ auto queueType = m_countersDb->hget(COUNTERS_QUEUE_TYPE_MAP, queueIdStr);`
`203`	`202`
`204`	`203`	`if (queueType.get() == nullptr \|\| *queueType != "SAI_QUEUE_TYPE_MULTICAST" \|\| !m_countersTable->get(queueIdStr, fieldValues))`
`205`	`204`	`{`
Original file line number	Diff line number	Diff line change
`@@ -364,9 +364,8 @@ void PfcWdSwOrch<DropHandler, ForwardHandler>::disableBigRedSwitchMode()`
`364`	`364`	`}`
`365`	`365`
`366`	`366`	`auto queueId = entry.first;`
`367`		`- RedisClient redisClient(this->getCountersDb().get());`
`368`	`367`	`string countersKey = this->getCountersTable()->getTableName() + this->getCountersTable()->getTableNameSeparator() + sai_serialize_object_id(queueId);`
`369`		`- redisClient.hdel(countersKey, "BIG_RED_SWITCH_MODE");`
	`368`	`+ this->getCountersDb()->hdel(countersKey, "BIG_RED_SWITCH_MODE");`
`370`	`369`	`}`
`371`	`370`
`372`	`371`	`m_brsEntryMap.clear();`
`@@ -633,9 +632,8 @@ void PfcWdSwOrch<DropHandler, ForwardHandler>::unregisterFromWdDb(const Port& po`
`633`	`632`	`m_entryMap.erase(queueId);`
`634`	`633`
`635`	`634`	`// Clean up`
`636`		`- RedisClient redisClient(this->getCountersDb().get());`
`637`	`635`	`string countersKey = this->getCountersTable()->getTableName() + this->getCountersTable()->getTableNameSeparator() + sai_serialize_object_id(queueId);`
`638`		`- redisClient.hdel(countersKey, {"PFC_WD_DETECTION_TIME", "PFC_WD_RESTORATION_TIME", "PFC_WD_ACTION", "PFC_WD_STATUS"});`
	`636`	`+ this->getCountersDb()->hdel(countersKey, {"PFC_WD_DETECTION_TIME", "PFC_WD_RESTORATION_TIME", "PFC_WD_ACTION", "PFC_WD_STATUS"});`
`639`	`637`	`}`
`640`	`638`
`641`	`639`	`}`
`@@ -657,8 +655,7 @@ PfcWdSwOrch<DropHandler, ForwardHandler>::PfcWdSwOrch(`
`657`	`655`	`c_queueAttrIds(queueAttrIds),`
`658`	`656`	`m_pollInterval(pollInterval),`
`659`	`657`	`m_applDb(make_shared<DBConnector>("APPL_DB", 0)),`
`660`		`- m_applTable(make_shared<Table>(m_applDb.get(), APP_PFC_WD_TABLE_NAME "_INSTORM")),`
`661`		`- m_applDbRedisClient(m_applDb.get())`
	`658`	`+ m_applTable(make_shared<Table>(m_applDb.get(), APP_PFC_WD_TABLE_NAME "_INSTORM"))`
`662`	`659`	`{`
`663`	`660`	`SWSS_LOG_ENTER();`
`664`	`661`
`@@ -934,7 +931,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string`
`934`	`931`	`entry->second.handler->initCounters();`
`935`	`932`	`// Log storm event to APPL_DB for warm-reboot purpose`
`936`	`933`	`string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;`
`937`		`- m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
	`934`	`+ m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
`938`	`935`	`}`
`939`	`936`	`}`
`940`	`937`	`else if (entry->second.action == PfcWdAction::PFC_WD_ACTION_DROP)`
`@@ -956,7 +953,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string`
`956`	`953`	`entry->second.handler->initCounters();`
`957`	`954`	`// Log storm event to APPL_DB for warm-reboot purpose`
`958`	`955`	`string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;`
`959`		`- m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
	`956`	`+ m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
`960`	`957`	`}`
`961`	`958`	`}`
`962`	`959`	`else if (entry->second.action == PfcWdAction::PFC_WD_ACTION_FORWARD)`
`@@ -978,7 +975,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string`
`978`	`975`	`entry->second.handler->initCounters();`
`979`	`976`	`// Log storm event to APPL_DB for warm-reboot purpose`
`980`	`977`	`string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;`
`981`		`- m_applDbRedisClient.hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
	`978`	`+ m_applDb->hset(key, to_string(entry->second.index), PFC_WD_IN_STORM);`
`982`	`979`	`}`
`983`	`980`	`}`
`984`	`981`	`else`
`@@ -1002,7 +999,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::startWdActionOnQueue(const string`
`1002`	`999`	`entry->second.handler = nullptr;`
`1003`	`1000`	`// Remove storm status in APPL_DB for warm-reboot purpose`
`1004`	`1001`	`string key = m_applTable->getTableName() + m_applTable->getTableNameSeparator() + entry->second.portAlias;`
`1005`		`- m_applDbRedisClient.hdel(key, to_string(entry->second.index));`
	`1002`	`+ m_applDb->hdel(key, to_string(entry->second.index));`
`1006`	`1003`	`}`
`1007`	`1004`	`}`
`1008`	`1005`	`else`
`@@ -1019,8 +1016,6 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::bake()`
`1019`	`1016`	`{`
`1020`	`1017`	`// clean all _last and _LEFT fields in COUNTERS_TABLE`
`1021`	`1018`	`// to allow warm-reboot pfc detect & restore state machine to enter the same init state as cold-reboot`
`1022`		`- RedisClient redisClient(this->getCountersDb().get());`
`1023`		`-`
`1024`	`1019`	`vector<string> cKeys;`
`1025`	`1020`	`this->getCountersTable()->getKeys(cKeys);`
`1026`	`1021`	`for (const auto &key : cKeys)`
`@@ -1037,7 +1032,7 @@ bool PfcWdSwOrch<DropHandler, ForwardHandler>::bake()`
`1037`	`1032`	`}`
`1038`	`1033`	`if (!wLasts.empty())`
`1039`	`1034`	`{`
`1040`		`- redisClient.hdel(`
	`1035`	`+ this->getCountersDb()->hdel(`
`1041`	`1036`	`this->getCountersTable()->getTableName()`
`1042`	`1037`	`+ this->getCountersTable()->getTableNameSeparator()`
`1043`	`1038`	`+ key,`