agent: backhaul_manager: add READY_FOR_MASTER_DISCOVERY state

https://jira.prplfoundation.org/browse/PPM-143

Add READY_FOR_MASTER_DISCOVERY state to backhaul_manager state machine.
In certification mode the agent state machine should stop before the MASTER_DISCOVERY state
and wait for dev_set_config (wired backhaul) or start_wps_registration (wireless backhaul).

In non-certification mode this state has no meaning,
the state will change to MASTER_DISCOVERY on the next tick of backhaul_manager_thread.

Signed-off-by: Vitalii Komisarenko <vitalii.komisarenko@gmail.com>

Author: vitalii-komisarenko

agent/src/beerocks/slave/agent_ucc_listener.cpp

@@ -61,8 +61,9 @@ std::string agent_ucc_listener::fill_version_reply_string()
  */
 void agent_ucc_listener::clear_configuration()
 {
-    m_in_reset        = true;
-    m_reset_completed = false;
+    m_in_reset                = true;
+    m_reset_completed         = false;
+    m_received_dev_set_config = false;
 
     auto timeout =
         std::chrono::steady_clock::now() + std::chrono::seconds(UCC_REPLY_COMPLETE_TIMEOUT_SEC);
@@ -221,6 +222,7 @@ bool agent_ucc_listener::handle_dev_set_config(std::unordered_map<std::string, s
 
     // Signal to backhaul that it can continue onboarding.
     m_in_reset = false;
+    m_received_dev_set_config = true;
     return true;
 }
 

agent/src/beerocks/slave/agent_ucc_listener.h

@@ -52,6 +52,9 @@ class agent_ucc_listener : public beerocks_ucc_listener {
      * again. This function allows the backhaul to signal that it has reached that state.
      */
     void reset_completed() { m_reset_completed = true; }
+
+    bool has_received_dev_set_config() { return m_received_dev_set_config; }
+
     std::string get_selected_backhaul();
     void update_vaps_list(std::string ruid, beerocks_message::sVapsList &vaps);
 
@@ -73,8 +76,9 @@ class agent_ucc_listener : public beerocks_ucc_listener {
     const std::string &m_bridge_iface;
     std::string m_bridge_mac;
 
-    bool m_in_reset        = false;
-    bool m_reset_completed = false;
+    bool m_in_reset                = false;
+    bool m_reset_completed         = false;
+    bool m_received_dev_set_config = false;
     std::string m_selected_backhaul; // "ETH" or "<RUID of the selected radio>"
 
     std::mutex mutex;

agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.cpp

@@ -841,7 +841,7 @@ bool backhaul_manager::backhaul_fsm_main(bool &skip_select)
         // Ignore 'selected_backhaul' since this case is not covered by certification flows
         if (db->device_conf.local_controller && db->device_conf.local_gw) {
             LOG(DEBUG) << "local controller && local gw";
-            FSM_MOVE_STATE(MASTER_DISCOVERY);
+            FSM_MOVE_STATE(READY_FOR_MASTER_DISCOVERY);
             db->backhaul.connection_type = AgentDB::sBackhaul::eConnectionType::Invalid;
             db->backhaul.selected_iface_name.clear();
         } else { // link establish
@@ -897,13 +897,36 @@ bool backhaul_manager::backhaul_fsm_main(bool &skip_select)
             if (db->backhaul.connection_type == AgentDB::sBackhaul::eConnectionType::Wireless) {
                 FSM_MOVE_STATE(INIT_HAL);
             } else { // EType::Wired
-                FSM_MOVE_STATE(MASTER_DISCOVERY);
+                FSM_MOVE_STATE(READY_FOR_MASTER_DISCOVERY);
             }
 
             skip_select = true;
         }
         break;
     }
+    case EState::READY_FOR_MASTER_DISCOVERY: {
+        auto certification_mode = bpl::cfg_get_certification_mode();
+        if (certification_mode < 0) {
+            LOG(ERROR) << "Failed reading certification_mode: " << certification_mode;
+            return false;
+        }
+        // In certification mode we want to wait till dev_set_config is received (wired backhaul)
+        // or start_wps_registration (wireless backhaul).
+        // Otherwise switch to MASTER_DISCOVERY
+        if (!certification_mode) {
+            FSM_MOVE_STATE(MASTER_DISCOVERY);
+        }
+
+        if (!m_agent_ucc_listener) {
+            LOG(ERROR) << "m_agent_ucc_listener == nullptr";
+            return false;
+        }
+
+        if (m_agent_ucc_listener->has_received_dev_set_config()) {
+            FSM_MOVE_STATE(MASTER_DISCOVERY);
+        }
+        break;
+    }
     case EState::MASTER_DISCOVERY: {
 
         auto db = AgentDB ::get();

agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.h

@@ -559,6 +559,7 @@ class backhaul_manager : public btl::transport_socket_thread {
     STATE(WIRELESS_WAIT_FOR_RECONNECT)                                                             \
     STATE(_WIRELESS_END_)                                                                          \
                                                                                                    \
+    STATE(READY_FOR_MASTER_DISCOVERY)                                                              \
     STATE(MASTER_DISCOVERY)                                                                        \
     STATE(SEND_AUTOCONFIG_SEARCH_MESSAGE)                                                          \
     STATE(WAIT_FOR_AUTOCONFIG_RESPONSE_MESSAGE)                                                    \