Add NSF warm restart registration support

Author: mint570

common/schema.h

@@ -412,6 +412,7 @@ after libswsscommon deb make.
 #define STATE_FDB_TABLE_NAME                        "FDB_TABLE"
 #define STATE_WARM_RESTART_TABLE_NAME               "WARM_RESTART_TABLE"
 #define STATE_WARM_RESTART_ENABLE_TABLE_NAME        "WARM_RESTART_ENABLE_TABLE"
+#define STATE_WARM_RESTART_REGISTRATION_TABLE_NAME  "WARM_RESTART_REGISTRATION_TABLE"
 #define STATE_VRF_TABLE_NAME                        "VRF_TABLE"
 #define STATE_VRF_OBJECT_TABLE_NAME                 "VRF_OBJECT_TABLE"
 #define STATE_MGMT_PORT_TABLE_NAME                  "MGMT_PORT_TABLE"

common/warm_restart.cpp

@@ -2,12 +2,17 @@
 #include <climits>
 #include "logger.h"
 #include "schema.h"
+#include "timestamp.h"
 #include "warm_restart.h"
 
 namespace swss {
 
 const std::string WarmStart::kNsfManagerNotificationChannel =
     "NSF_MANAGER_COMMON_NOTIFICATION_CHANNEL";
+const std::string WarmStart::kRegistrationFreezeKey = "freeze";
+const std::string WarmStart::kRegistrationCheckpointKey = "checkpoint";
+const std::string WarmStart::kRegistrationReconciliationKey = "reconciliation";
+const std::string WarmStart::kRegistrationTimestampKey = "timestamp";
 
 const WarmStart::WarmStartStateNameMap WarmStart::warmStartStateNameMap =
 {
@@ -69,6 +74,9 @@ void WarmStart::initialize(const std::string &app_name,
         return;
     }
 
+    warmStart.m_appName = app_name;
+    warmStart.m_dockerName = docker_name;
+
     /* Use unix socket for db connection by default */
     warmStart.m_stateDb =
         std::make_shared<swss::DBConnector>("STATE_DB", db_timeout, isTcpConn);
@@ -85,6 +93,70 @@ void WarmStart::initialize(const std::string &app_name,
     warmStart.m_initialized = true;
 }
 
+/*
+ * registerWarmBootInfo
+ *
+ * Register an application with NSF Manager.
+ *
+ * Returns: true on success, false otherwise.
+ *
+ * wait_for_freeze: if true, NSF Manager waits for application to freeze
+ *                  and become quiescent before proceeding to state
+ *                  verification and checkpointing
+ * wait_for_checkpoint: if true, NSF Manager waits for application to
+ *                      complete checkpointing before reboot
+ * wait_for_reconciliation: if true, NSF Manager waits for application to
+ *                          complete reconciliation before unfreeze
+ */
+bool WarmStart::registerWarmBootInfo(bool wait_for_freeze,
+                                     bool wait_for_checkpoint,
+                                     bool wait_for_reconciliation) {
+    auto& warmStart = getInstance();
+
+    if (!warmStart.m_initialized) {
+        SWSS_LOG_ERROR("registerWarmBootInfo called before initialized");
+        return false;
+    }
+
+    if (warmStart.m_dockerName.empty()) {
+        SWSS_LOG_ERROR("registerWarmBootInfo: m_dockerName is empty");
+        return false;
+    }
+
+    if (warmStart.m_appName.empty()) {
+        SWSS_LOG_ERROR("registerWarmBootInfo: m_appName is empty");
+        return false;
+    }
+
+    std::unique_ptr<Table> stateWarmRestartRegistrationTable =
+        std::unique_ptr<Table>(
+            new Table(warmStart.m_stateDb.get(),
+                      STATE_WARM_RESTART_REGISTRATION_TABLE_NAME));
+
+    std::string separator =
+        TableBase::getTableSeparator(warmStart.m_stateDb->getDbId());
+    std::string tableName =
+        warmStart.m_dockerName + separator + warmStart.m_appName;
+
+    std::vector<FieldValueTuple> values;
+
+    values.push_back(swss::FieldValueTuple(WarmStart::kRegistrationFreezeKey,
+                                           wait_for_freeze ? "true" : "false"));
+    values.push_back(swss::FieldValueTuple(
+        WarmStart::kRegistrationCheckpointKey,
+        wait_for_checkpoint ? "true" : "false"));
+    values.push_back(swss::FieldValueTuple(
+        WarmStart::kRegistrationReconciliationKey,
+        wait_for_reconciliation ? "true" : "false"));
+    values.push_back(swss::FieldValueTuple(
+        WarmStart::kRegistrationTimestampKey,
+        getTimestamp()));
+
+    stateWarmRestartRegistrationTable->set(tableName, values);
+
+    return true;
+}
+
 /*
  * <1> Upon system reboot, the system enable knob will be checked.
  * If enabled, database data will be preserved, if not, database will be flushed.

common/warm_restart.h

@@ -14,6 +14,10 @@ class WarmStart
 {
 public:
     static const std::string kNsfManagerNotificationChannel;
+    static const std::string kRegistrationFreezeKey;
+    static const std::string kRegistrationCheckpointKey;
+    static const std::string kRegistrationReconciliationKey;
+    static const std::string kRegistrationTimestampKey;
 
     enum WarmStartState
     {
@@ -63,6 +67,10 @@ class WarmStart
                            unsigned int db_timeout = 0,
                            bool isTcpConn = false);
 
+    static bool registerWarmBootInfo(bool wait_for_freeze,
+                                     bool wait_for_checkpoint,
+                                     bool wait_for_reconciliation);
+
     static bool checkWarmStart(const std::string &app_name,
                                const std::string &docker_name,
                                const bool incr_restore_cnt = true);
@@ -95,6 +103,8 @@ class WarmStart
     bool                                 m_initialized;
     bool                                 m_enabled;
     bool                                 m_systemWarmRebootEnabled;
+    std::string                          m_appName;
+    std::string                          m_dockerName;
 };
 
 }

tests/warm_restart_ut.cpp

@@ -11,6 +11,14 @@ using namespace swss;
 static const string testAppName = "TestApp";
 static const string testDockerName = "TestDocker";
 
+// This test must be executed before first successful call to initialize()
+// The static elements of this class can only be initialized once.
+TEST(WarmRestart, testRegisterWarmBootInfoNotInitialized)
+{
+    bool ret = WarmStart::registerWarmBootInfo(true,false,false);
+    EXPECT_FALSE(ret);
+}
+
 TEST(WarmRestart, checkWarmStart_and_State)
 {
     DBConnector stateDb("STATE_DB", 0, true);
@@ -252,3 +260,62 @@ TEST(WarmRestart, testNotificationMaps)
         EXPECT_EQ(notification, currNotification);
     }
 }
+
+TEST(WarmRestart, testRegisterWarmBootInfo)
+{
+    DBConnector stateDb("STATE_DB", 0, true);
+    Table stateWarmRestartRegTable(&stateDb,
+                                   STATE_WARM_RESTART_REGISTRATION_TABLE_NAME);
+
+    std::string tableName = testDockerName + "|" + testAppName;
+
+    //Clean up warm restart state for testAppName
+    stateWarmRestartRegTable.del(tableName);
+
+    //Initialize WarmStart class for TestApp
+    WarmStart::initialize(testAppName, testDockerName, 0, true);
+
+    bool ret = WarmStart::registerWarmBootInfo(true,false,false);
+    EXPECT_TRUE(ret);
+
+    std::string value;
+    ret = stateWarmRestartRegTable.hget(tableName,
+                                        WarmStart::kRegistrationFreezeKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "true");
+
+    ret = stateWarmRestartRegTable.hget(
+        tableName, WarmStart::kRegistrationCheckpointKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "false");
+
+    ret = stateWarmRestartRegTable.hget(
+        tableName, WarmStart::kRegistrationReconciliationKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "false");
+
+    ret = stateWarmRestartRegTable.hget(
+        tableName, WarmStart::kRegistrationTimestampKey, value);
+    EXPECT_TRUE(ret);
+
+    ret = WarmStart::registerWarmBootInfo(false,true,false);
+    EXPECT_TRUE(ret);
+
+    ret = stateWarmRestartRegTable.hget(tableName,
+                                        WarmStart::kRegistrationFreezeKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "false");
+
+    ret = stateWarmRestartRegTable.hget(
+        tableName, WarmStart::kRegistrationCheckpointKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "true");
+
+    ret = WarmStart::registerWarmBootInfo(false,false,true);
+    EXPECT_TRUE(ret);
+
+    ret = stateWarmRestartRegTable.hget(
+        tableName, WarmStart::kRegistrationReconciliationKey, value);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(value, "true");
+}