Upstream SONiC getWarmStartState() API and Create returnWarmStartState as a wrapper.

Author: mint570

common/warm_restart.cpp

@@ -59,6 +59,18 @@ WarmStart &WarmStart::getInstance(void)
     return m_warmStart;
 }
 
+void WarmStart::updateStateOnColdBoot(const std::string& app_name)
+{
+    /* Default state for cold boot is:
+     * a) COMPLETED when state verification is enabled. This is because
+     *    enabling state verification results in unfreeze notification.
+     * b) RECONCILED when state verification is disabled. This is the
+     *    default behavior.
+     */
+    const auto state = isStateVerificationEnabled() ? COMPLETED : RECONCILED;
+    setWarmStartState(app_name, state);
+}
+
 /*
  * WarmStart's initialization method -- to be invoked once per application.
  */
@@ -221,6 +233,10 @@ bool WarmStart::checkWarmStart(const std::string &app_name,
         warmStart.m_enabled = false;
         warmStart.m_systemWarmRebootEnabled = false;
         warmStart.m_stateWarmRestartTable->hset(app_name, "restore_count", "0");
+        if (app_name == warmStart.m_appName)
+        {
+            updateStateOnColdBoot(app_name);
+        }
         return false;
     }
 
@@ -329,6 +345,15 @@ void WarmStart::getWarmStartState(const std::string &app_name, WarmStartState &s
     return;
 }
 
+// Wrap getWarmStartState to return state vs passing a state variable by
+// reference. SWIG (for python) does not handle passing enum by reference
+// cleanly.
+WarmStart::WarmStartState WarmStart::returnWarmStartState(const std::string &app_name)
+{
+    WarmStartState state;
+    getWarmStartState(app_name, state);
+    return state;
+}
 // Set the WarmStart FSM state for a particular application.
 void WarmStart::setWarmStartState(const std::string &app_name, WarmStartState state)
 {
@@ -404,4 +429,24 @@ WarmStart::DataCheckState WarmStart::getDataCheckState(const std::string &app_na
     return state;
 }
 
+bool WarmStart::isStateVerificationEnabled()
+{
+    auto& warmStart = getInstance();
+
+    std::string value;
+    warmStart.m_stateWarmRestartEnableTable->hget("system",
+                                                  "state_verification", value);
+    if (value == "true")
+    {
+        return true;
+    }
+    return false;
+}
+
+bool WarmStart::waitForUnfreeze()
+{
+    // Wait for unfreeze notification only if state verification is enabled.
+    return isStateVerificationEnabled();
+}
+
 } // namespace swss

common/warm_restart.h

@@ -62,6 +62,8 @@ class WarmStart
 
     static WarmStart &getInstance(void);
 
+    static void updateStateOnColdBoot(const std::string& app_name);
+
     static void initialize(const std::string &app_name,
                            const std::string &docker_name,
                            unsigned int db_timeout = 0,
@@ -82,6 +84,10 @@ class WarmStart
     static void getWarmStartState(const std::string &app_name,
                                   WarmStartState    &state);
 
+    // For python via SWIG: return state instead of passing state
+    // variable by reference as a parameter.
+    static WarmStartState returnWarmStartState(const std::string &app_name);
+
     static void setWarmStartState(const std::string &app_name,
                                   WarmStartState     state);
 
@@ -94,6 +100,8 @@ class WarmStart
 
     static DataCheckState getDataCheckState(const std::string &app_name,
                                             DataCheckStage stage);
+    static bool isStateVerificationEnabled();
+    static bool waitForUnfreeze();
 private:
     std::shared_ptr<swss::DBConnector>   m_stateDb;
     std::shared_ptr<swss::DBConnector>   m_cfgDb;

tests/warm_restart_ut.cpp

@@ -11,6 +11,28 @@ using namespace swss;
 static const string testAppName = "TestApp";
 static const string testDockerName = "TestDocker";
 
+void verifyWarmbootState(std::string app,
+                         WarmStart::WarmStartState expected_state)
+{
+    WarmStart::WarmStartState state;
+    WarmStart::getWarmStartState(app, state);
+    EXPECT_EQ(state, expected_state);
+
+    DBConnector stateDb("STATE_DB", 0, true);
+    Table stateWarmRestartTable(&stateDb, STATE_WARM_RESTART_TABLE_NAME);
+    std::string state_str;
+    stateWarmRestartTable.hget(app, "state", state_str);
+    EXPECT_EQ(state_str, WarmStart::warmStartStateNameMap()->at(state).c_str());
+}
+
+void configureStateVerification(std::string value)
+{
+    DBConnector stateDb("STATE_DB", 0, true);
+    Table stateWarmRestartEnableTable(&stateDb,
+                                      STATE_WARM_RESTART_ENABLE_TABLE_NAME);
+    stateWarmRestartEnableTable.hset("system", "state_verification", value);
+}
+
 // 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)
@@ -144,8 +166,6 @@ TEST(WarmRestart, checkWarmStart_and_State)
     EXPECT_FALSE(system_enabled);
 }
 
-
-
 TEST(WarmRestart, getWarmStartTimer)
 {
     DBConnector configDb("CONFIG_DB", 0, true);
@@ -168,6 +188,42 @@ TEST(WarmRestart, getWarmStartTimer)
     EXPECT_EQ(timer, 5000u);
 }
 
+TEST(WarmRestart, returnWarmStartState)
+{
+    DBConnector stateDb("STATE_DB", 0, true);
+    Table stateWarmRestartTable(&stateDb, STATE_WARM_RESTART_TABLE_NAME);
+    //
+    //Initialize WarmStart class for TestApp
+    WarmStart::initialize(testAppName, testDockerName, 0, true);
+
+    WarmStart::WarmStartState warmStartStates[] =
+        {
+            WarmStart::INITIALIZED,
+            WarmStart::RESTORED,
+            WarmStart::REPLAYED,
+            WarmStart::RECONCILED,
+            WarmStart::WSDISABLED,
+            WarmStart::WSUNKNOWN,
+            WarmStart::FROZEN,
+            WarmStart::QUIESCENT,
+            WarmStart::CHECKPOINTED,
+            WarmStart::COMPLETED,
+            WarmStart::FAILED,
+        };
+
+    for (const auto &currState : warmStartStates) {
+        WarmStart::setWarmStartState(testAppName, currState);
+
+        string state;
+        stateWarmRestartTable.hget(testAppName, "state", state);
+        EXPECT_EQ(state, WarmStart::warmStartStateNameMap()->at(currState).c_str());
+
+        WarmStart::WarmStartState ret_state;
+        ret_state = WarmStart::returnWarmStartState(testAppName);
+        EXPECT_EQ(ret_state, currState);
+    }
+}
+
 TEST(WarmRestart, set_get_DataCheckState)
 {
     DBConnector stateDb("STATE_DB", 0, true);
@@ -319,3 +375,66 @@ TEST(WarmRestart, testRegisterWarmBootInfo)
     EXPECT_TRUE(ret);
     EXPECT_EQ(value, "true");
 }
+
+TEST(WarmRestart, testOptionalStateVerification)
+{
+    DBConnector stateDb("STATE_DB", 0, true);
+    Table stateWarmRestartTable(&stateDb, STATE_WARM_RESTART_TABLE_NAME);
+    Table stateWarmRestartEnableTable(&stateDb,
+                                      STATE_WARM_RESTART_ENABLE_TABLE_NAME);
+
+    DBConnector configDb("CONFIG_DB", 0, true);
+    Table cfgWarmRestartTable(&configDb, CFG_WARM_RESTART_TABLE_NAME);
+
+    // Clean up warm restart state for testAppName and warm restart config for
+    // testDockerName
+    stateWarmRestartTable.del(testAppName);
+    cfgWarmRestartTable.del(testDockerName);
+    stateWarmRestartEnableTable.del("system");
+    stateWarmRestartEnableTable.del(testDockerName);
+
+    // Initialize WarmStart class for TestApp
+    WarmStart::initialize(testAppName, testDockerName, 0, true);
+
+    // perform checkWarmStart for TestApp running in TestDocker. This updates
+    // warmboot state in the DB.
+    EXPECT_FALSE(WarmStart::checkWarmStart(testAppName, testDockerName));
+
+    // State verification is disabled by default.
+    EXPECT_FALSE(WarmStart::isStateVerificationEnabled());
+    EXPECT_FALSE(WarmStart::waitForUnfreeze());
+    // Since state verification is disabled by default, warmboot state should be
+    // RECONCILED.
+    verifyWarmbootState(testAppName, WarmStart::RECONCILED);
+
+    // Disable system level warm restart. Verify that checkWarmStart() still
+    // updates warmboot state to RECONCILED since state verification is disabled
+    // by default.
+    stateWarmRestartEnableTable.hset("system", "enable", "false");
+    EXPECT_FALSE(WarmStart::isStateVerificationEnabled());
+    EXPECT_FALSE(WarmStart::waitForUnfreeze());
+    EXPECT_FALSE(WarmStart::checkWarmStart(testAppName, testDockerName));
+    verifyWarmbootState(testAppName, WarmStart::RECONCILED);
+
+    // Enable state verification but disable warm restart. Verify that
+    // checkWarmStart() updates warmboot state to COMPLETED since state
+    // verification is enabled.
+    configureStateVerification("true");
+    EXPECT_TRUE(WarmStart::isStateVerificationEnabled());
+    EXPECT_TRUE(WarmStart::waitForUnfreeze());
+    EXPECT_FALSE(WarmStart::checkWarmStart(testAppName, testDockerName));
+    verifyWarmbootState(testAppName, WarmStart::COMPLETED);
+
+    // Set warmboot state and enable system level warm restart. Verify that
+    // warmboot state reflects the configured state and doesn't get updated by
+    // checkWarmStart().
+    WarmStart::setWarmStartState(testAppName, WarmStart::INITIALIZED);
+    stateWarmRestartEnableTable.hset("system", "enable", "true");
+    EXPECT_TRUE(WarmStart::checkWarmStart(testAppName, testDockerName));
+    verifyWarmbootState(testAppName, WarmStart::INITIALIZED);
+
+    // Disable state verification.
+    configureStateVerification("false");
+    EXPECT_FALSE(WarmStart::isStateVerificationEnabled());
+    EXPECT_FALSE(WarmStart::waitForUnfreeze());
+}