[ssw][ha] haorch consumes dpu_ appl_db to create bfd passive sessions on DPU (#3790)

What I did
[ssw][ha] haorch consumes dpu_ appl_db to create bfd passive sessions on DPU
Per HLD, creating BFD passive sessions on DPU side when HA state is activated.
Also removing the passive sessions in planned shutdown. This is only applicable to DPU scope HA.

Why I did it
BFD sessions need to be created on DPU side proactively.

How I verified it
Tested on Cisco SSW. BFD sessions can be created as expected.

Author: zjswhhh

orchagent/bfdorch.cpp

@@ -703,6 +703,29 @@ void BfdOrch::handleTsaStateChange(bool tsaState)
     }
 }
 
+void BfdOrch::createSoftwareBfdSession(const string &key, const vector<swss::FieldValueTuple>& data)
+{
+    m_stateSoftBfdSessionTable->set(createStateDBKey(key), data);
+    SWSS_LOG_NOTICE("Software BFD session created for %s", key.c_str());
+}
+
+void BfdOrch::removeSoftwareBfdSession(const string &key)
+{
+    m_stateSoftBfdSessionTable->del(createStateDBKey(key));
+    SWSS_LOG_NOTICE("Software BFD session removed for %s", key.c_str());
+}
+
+void BfdOrch::removeAllSoftwareBfdSessions()
+{
+    vector<string> keys;
+    m_stateSoftBfdSessionTable->getKeys(keys);
+
+    for (auto key : keys)
+    {
+        removeSoftwareBfdSession(key);
+    }
+}
+
 BgpGlobalStateOrch::BgpGlobalStateOrch(DBConnector *db, string tableName):
     Orch(db, tableName)
 {

orchagent/bfdorch.h

@@ -19,6 +19,14 @@ class BfdOrch: public Orch, public Subject
     virtual ~BfdOrch(void);
     void handleTsaStateChange(bool tsaState);
 
+    /* APIs for HaOrch to create passive BFD sessions on DPU.*/
+    virtual void createSoftwareBfdSession(
+        const std::string& key,
+        const std::vector<swss::FieldValueTuple>& data);
+    virtual void removeSoftwareBfdSession(
+        const std::string& key);
+    virtual void removeAllSoftwareBfdSessions();
+
 private:
     bool create_bfd_session(const std::string& key, const std::vector<swss::FieldValueTuple>& data);
     bool remove_bfd_session(const std::string& key);

orchagent/dash/dashhaorch.cpp

@@ -3,6 +3,7 @@
 #include "orch.h"
 #include "sai.h"
 #include "saiextensions.h"
+#include "bfdorch.h"
 #include "dashorch.h"
 #include "crmorch.h"
 #include "saihelper.h"
@@ -58,9 +59,10 @@ static const map<sai_ha_scope_event_t, string> sai_ha_scope_event_type_name =
     { SAI_HA_SCOPE_EVENT_SPLIT_BRAIN_DETECTED, "split_brain_detected" }
 };
 
-DashHaOrch::DashHaOrch(DBConnector *db, const vector<string> &tables, DashOrch *dash_orch, DBConnector *app_state_db, ZmqServer *zmqServer) :
+DashHaOrch::DashHaOrch(DBConnector *db, const vector<string> &tables, DashOrch *dash_orch, BfdOrch *bfd_orch, DBConnector *app_state_db, ZmqServer *zmqServer) :
     ZmqOrch(db, tables, zmqServer),
-    m_dash_orch(dash_orch)
+    m_dash_orch(dash_orch),
+    m_bfd_orch(bfd_orch)
 {
     SWSS_LOG_ENTER();
 
@@ -524,7 +526,7 @@ bool DashHaOrch::addHaScopeEntry(const std::string &key, const dash::ha_scope::H
             return parseHandleSaiStatusFailure(handle_status);
         }
     }
-    m_ha_scope_entries[key] = HaScopeEntry {sai_ha_scope_oid, entry, getNowTime()};
+    m_ha_scope_entries[key] = HaScopeEntry {sai_ha_scope_oid, entry, getNowTime(), SAI_DASH_HA_STATE_DEAD, getNowTime()};
     SWSS_LOG_NOTICE("Created HA Scope object for %s", key.c_str());
 
     // set HA Scope ID to ENI
@@ -574,6 +576,18 @@ bool DashHaOrch::setHaScopeHaRole(const std::string &key, const dash::ha_scope::
 
     sai_object_id_t ha_scope_id = m_ha_scope_entries[key].ha_scope_id;
 
+    /*
+        Remove bfd passive sessions in planned shutdown (scope == DPU)
+    */
+    if (entry.ha_role() == dash::types::HA_ROLE_DEAD
+        && !m_ha_set_entries.empty())
+    {
+        if (has_dpu_scope())
+        {
+            m_bfd_orch->removeAllSoftwareBfdSessions();
+        }
+    }
+
     sai_attribute_t ha_scope_attr;
     ha_scope_attr.id = SAI_HA_SCOPE_ATTR_DASH_HA_ROLE;
     ha_scope_attr.value.u32 = to_sai(entry.ha_role());
@@ -806,6 +820,68 @@ void DashHaOrch::doTaskHaScopeTable(ConsumerBase &consumer)
     }
 }
 
+void DashHaOrch::doTaskBfdSessionTable(ConsumerBase &consumer)
+{
+    SWSS_LOG_ENTER();
+
+    auto it = consumer.m_toSync.begin();
+    while (it != consumer.m_toSync.end())
+    {
+        KeyOpFieldsValuesTuple tuple = it->second;
+        const auto& key = kfvKey(tuple);
+        const auto& op = kfvOp(tuple);
+
+        SWSS_LOG_DEBUG("Processing BFD Session table");
+
+        if (op == SET_COMMAND)
+        {
+            if (has_eni_scope())
+            {
+                m_bfd_orch->createSoftwareBfdSession(key, kfvFieldsValues(tuple));
+            }
+
+            // Per HLD, once the state is moved to Active/Standby/Standalone state, we will create the BFD responder on DPU.
+            bool has_dpu_scope_ha_state_activated = false;
+            if (has_dpu_scope())
+            {
+                for (const auto& ha_scope_entry : m_ha_scope_entries)
+                {
+                    if (in(ha_scope_entry.second.ha_state, {SAI_DASH_HA_STATE_ACTIVE,
+                                                            SAI_DASH_HA_STATE_STANDBY,
+                                                            SAI_DASH_HA_STATE_STANDALONE}))
+                    {
+                        has_dpu_scope_ha_state_activated = true;
+                        break;
+                    }
+                }
+            }
+
+            if (has_dpu_scope_ha_state_activated)
+            {
+                m_bfd_orch->createSoftwareBfdSession(key, kfvFieldsValues(tuple));
+            }
+
+            /*
+                Caching BFD sessions for planned ha_role up->down->up.
+            */
+            if ((!has_eni_scope()))
+            {
+                SWSS_LOG_INFO("Caching BFD session %s as there is no non-dead DPU HA Scope", key.c_str());
+
+                m_bfd_session_pending_creation[key] = kfvFieldsValues(tuple);
+            }
+
+            it = consumer.m_toSync.erase(it);
+        }
+        else if (op == DEL_COMMAND)
+        {
+            m_bfd_orch->removeSoftwareBfdSession(key);
+            it = consumer.m_toSync.erase(it);
+            m_bfd_session_pending_creation.erase(key);
+        }
+    }
+}
+
 void DashHaOrch::doTask(ConsumerBase &consumer)
 {
     SWSS_LOG_ENTER();
@@ -817,7 +893,12 @@ void DashHaOrch::doTask(ConsumerBase &consumer)
     else if (consumer.getTableName() == APP_DASH_HA_SCOPE_TABLE_NAME)
     {
         doTaskHaScopeTable(consumer);
-    } else
+    }
+    else if (consumer.getTableName() ==  APP_BFD_SESSION_TABLE_NAME)
+    {
+        doTaskBfdSessionTable(consumer);
+    }
+    else
     {
         SWSS_LOG_ERROR("Unknown table: %s", consumer.getTableName().c_str());
     }
@@ -929,6 +1010,17 @@ void DashHaOrch::doTask(NotificationConsumer &consumer)
                         }
 
                         fvs.push_back({"ha_state", sai_ha_state_name.at(ha_scope_event[i].ha_state)});
+                        fvs.push_back({"ha_state_start_time", to_string(now_time)});
+
+                        m_ha_scope_entries[key].ha_state = ha_scope_event[i].ha_state;
+                        m_ha_scope_entries[key].last_state_start_time = now_time;
+
+                        if (has_dpu_scope() && in(ha_scope_event[i].ha_state, {SAI_DASH_HA_STATE_ACTIVE,
+                                                            SAI_DASH_HA_STATE_STANDBY,
+                                                            SAI_DASH_HA_STATE_STANDALONE}))
+                        {
+                            processCachedBfdSessions();
+                        }
                         break;
                     default:
                         SWSS_LOG_ERROR("Unknown HA Scope event type %d for %s", event_type, key.c_str());
@@ -1113,4 +1205,42 @@ bool DashHaOrch::convertKfvToHaScopePb(const std::vector<FieldValueTuple> &kfv,
         }
     }
     return true;
-}
+}
+
+bool DashHaOrch::has_dpu_scope()
+{
+    for (const auto& ha_set_entry : m_ha_set_entries)
+    {
+        if (ha_set_entry.second.metadata.scope() == dash::types::HA_SCOPE_DPU)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool DashHaOrch::has_eni_scope()
+{
+    for (const auto& ha_set_entry : m_ha_set_entries)
+    {
+        if (ha_set_entry.second.metadata.scope() == dash::types::HA_SCOPE_ENI)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void DashHaOrch::processCachedBfdSessions()
+{
+    /*
+        Create bfd passive sessions cached when moving out of DEAD role (scope == DPU)
+    */
+    if (has_dpu_scope() && !m_bfd_session_pending_creation.empty())
+    {
+        for (const auto& bfd_entry : m_bfd_session_pending_creation)
+        {
+            m_bfd_orch->createSoftwareBfdSession(bfd_entry.first, bfd_entry.second);
+        }
+    }
+}

orchagent/dash/dashhaorch.h

@@ -4,6 +4,7 @@
 
 #include "dbconnector.h"
 #include "dashorch.h"
+#include "bfdorch.h"
 #include "zmqorch.h"
 #include "zmqserver.h"
 #include "saitypes.h"
@@ -28,10 +29,14 @@ struct HaScopeEntry
     sai_object_id_t ha_scope_id;
     dash::ha_scope::HaScope metadata;
     std::time_t last_role_start_time;
+
+    sai_dash_ha_state_t ha_state;
+    std::time_t last_state_start_time;
 };
 
 typedef std::map<std::string, HaSetEntry> HaSetTable;
 typedef std::map<std::string, HaScopeEntry> HaScopeTable;
+typedef std::map<std::string, vector<swss::FieldValueTuple>> DashBfdSessionTable;
 
 template <typename T>
 bool in(T value, std::initializer_list<T> list) {
@@ -41,19 +46,22 @@ bool in(T value, std::initializer_list<T> list) {
 class DashHaOrch : public ZmqOrch
 {
 public:
-    DashHaOrch(swss::DBConnector *db, const std::vector<std::string> &tableNames, DashOrch *dash_orch, swss::DBConnector *app_state_db, swss::ZmqServer *zmqServer);
+    DashHaOrch(swss::DBConnector *db, const std::vector<std::string> &tableNames, DashOrch *dash_orch, BfdOrch *bfd_orch, swss::DBConnector *app_state_db, swss::ZmqServer *zmqServer);
 
 protected:
     HaSetTable m_ha_set_entries;
     HaScopeTable m_ha_scope_entries;
+    DashBfdSessionTable m_bfd_session_pending_creation;
 
     DashOrch *m_dash_orch;
+    BfdOrch *m_bfd_orch;
 
     void doTask(ConsumerBase &consumer);
     void doTask(swss::NotificationConsumer &consumer);
     void doTaskEniTable(ConsumerBase &consumer);
     void doTaskHaSetTable(ConsumerBase &consumer);
     void doTaskHaScopeTable(ConsumerBase &consumer);
+    void doTaskBfdSessionTable(ConsumerBase &consumer);
 
     bool addHaSetEntry(const std::string &key, const dash::ha_set::HaSet &entry);
     bool removeHaSetEntry(const std::string &key);
@@ -67,6 +75,11 @@ class DashHaOrch : public ZmqOrch
     bool register_ha_set_notifier();
     bool register_ha_scope_notifier();
 
+    bool has_dpu_scope();
+    bool has_eni_scope();
+
+    void processCachedBfdSessions();
+
     bool convertKfvToHaSetPb(
         const std::vector<swss::FieldValueTuple> &kfv,
         dash::ha_set::HaSet &entry
@@ -96,6 +109,7 @@ class DashHaOrch : public ZmqOrch
 public:
     const HaSetTable& getHaSetEntries() const { return m_ha_set_entries; };
     const HaScopeTable& getHaScopeEntries() const { return m_ha_scope_entries; };
+    const DashBfdSessionTable& getBfdSessionPendingCreation() const { return m_bfd_session_pending_creation; };
 };
 
 #endif // DASHHAORCH_H

orchagent/orchdaemon.cpp

@@ -1280,10 +1280,11 @@ bool DpuOrchDaemon::init()
 
     vector<string> dash_ha_tables = {
         APP_DASH_HA_SET_TABLE_NAME,
-        APP_DASH_HA_SCOPE_TABLE_NAME
+        APP_DASH_HA_SCOPE_TABLE_NAME,
+        APP_BFD_SESSION_TABLE_NAME
     };
 
-    DashHaOrch *dash_ha_orch = new DashHaOrch(m_dpu_appDb, dash_ha_tables, dash_orch, m_dpu_appstateDb, dash_zmq_server);
+    DashHaOrch *dash_ha_orch = new DashHaOrch(m_dpu_appDb, dash_ha_tables, dash_orch, gBfdOrch, m_dpu_appstateDb, dash_zmq_server);
     gDirectory.set(dash_ha_orch);
 
     vector<string> dash_route_tables = {