[tlm_teamd]: Try to add LAG again, when teamd is not ready first time (…

…sonic-net#1347)

* Postpone add LAG operation, when can't add right away

* Set empty log function for teamdctl library

* Return empty list if there is no ports in the PortChannel

Co-authored-by: PS <ps@cs.com>

tlm_teamd/main.cpp

@@ -107,6 +107,7 @@ int main()
  }
  else if (res == swss::Select::TIMEOUT)
  {
+ teamdctl_mgr.process_add_queue();
  values_store.update(teamdctl_mgr.get_dumps());
  }
  else

tlm_teamd/teamdctl_mgr.cpp

@@ -1,9 +1,28 @@
 #include <cstring>
+#include <algorithm>
 
 #include <logger.h>
 
 #include "teamdctl_mgr.h"
 
+///
+/// Custom function for libteamdctl logger. IT is empty to prevent libteamdctl to spam us with the error messages
+/// @param tdc teamdctl descriptor
+/// @param priority priority of the message
+/// @param file file where error was raised
+/// @param line line in the file where error was raised
+/// @param fn function where the error was raised
+/// @param format format of the error message
+/// @param args arguments of the error message
+void teamdctl_log_function(struct teamdctl *tdc, int priority,
+ const char *file, int line,
+ const char *fn, const char *format,
+ va_list args)
+{
+
+}
+
+
 ///
 /// The destructor clean up handlers to teamds
 ///
@@ -31,10 +50,11 @@ bool TeamdCtlMgr::has_key(const std::string & lag_name) const
 }
 
 ///
-/// Adds a LAG interface with lag_name to the manager
-/// This method allocates structures to connect to teamd
+/// Public method to add a LAG interface with lag_name to the manager
+/// This method tries to add. If the method can't add the LAG interface,
+/// this action will be postponed.
 /// @param lag_name a name for LAG interface
-/// @return true if the lag was added successfully, false otherwise
+/// @return true if the lag was added or postponed successfully, false otherwise
 ///
 bool TeamdCtlMgr::add_lag(const std::string & lag_name)
 {
@@ -43,26 +63,51 @@ bool TeamdCtlMgr::add_lag(const std::string & lag_name)
  SWSS_LOG_DEBUG("The LAG '%s' was already added. Skip adding it.", lag_name.c_str());
  return true;
  }
- else
+ return try_add_lag(lag_name);
+}
+
+///
+/// Try to adds a LAG interface with lag_name to the manager
+/// This method allocates structures to connect to teamd
+/// if the method can't add, it will retry to add next time
+/// @param lag_name a name for LAG interface
+/// @return true if the lag was added successfully, false otherwise
+///
+bool TeamdCtlMgr::try_add_lag(const std::string & lag_name)
+{
+ if (m_lags_to_add.find(lag_name) == m_lags_to_add.end())
  {
- auto tdc = teamdctl_alloc();
- if (!tdc)
- {
- SWSS_LOG_ERROR("Can't allocate memory for teamdctl handler. LAG='%s'", lag_name.c_str());
- return false;
- }
+ m_lags_to_add[lag_name] = 0;
+ }
 
- int err = teamdctl_connect(tdc, lag_name.c_str(), nullptr, nullptr);
- if (err)
+ int attempt = m_lags_to_add[lag_name];
+
+ auto tdc = teamdctl_alloc();
+ if (!tdc)
+ {
+ SWSS_LOG_ERROR("Can't allocate memory for teamdctl handler. LAG='%s'. attempt=%d", lag_name.c_str(), attempt);
+ m_lags_to_add[lag_name]++;
+ return false;
+ }
+
+ teamdctl_set_log_fn(tdc, &teamdctl_log_function);
+
+ int err = teamdctl_connect(tdc, lag_name.c_str(), nullptr, nullptr);
+ if (err)
+ {
+ if (attempt != 0)
  {
- SWSS_LOG_ERROR("Can't connect to teamd LAG='%s', error='%s'", lag_name.c_str(), strerror(-err));
- teamdctl_free(tdc);
- return false;
+ SWSS_LOG_WARN("Can't connect to teamd LAG='%s', error='%s'. attempt=%d", lag_name.c_str(), strerror(-err), attempt);
  }
- m_handlers.emplace(lag_name, tdc);
- SWSS_LOG_NOTICE("The LAG '%s' has been added.", lag_name.c_str());
+ teamdctl_free(tdc);
+ m_lags_to_add[lag_name]++;
+ return false;
  }
 
+ m_handlers.emplace(lag_name, tdc);
+ m_lags_to_add.erase(lag_name);
+ SWSS_LOG_NOTICE("The LAG '%s' has been added.", lag_name.c_str());
+
  return true;
 }
 
@@ -82,13 +127,39 @@ bool TeamdCtlMgr::remove_lag(const std::string & lag_name)
  m_handlers.erase(lag_name);
  SWSS_LOG_NOTICE("The LAG '%s' has been removed.", lag_name.c_str());
  }
+ else if (m_lags_to_add.find(lag_name) != m_lags_to_add.end())
+ {
+ m_lags_to_add.erase(lag_name);
+ SWSS_LOG_DEBUG("The LAG '%s' has been removed from adding queue.", lag_name.c_str());
+ }
  else
  {
  SWSS_LOG_WARN("The LAG '%s' hasn't been added. Can't remove it", lag_name.c_str());
  }
  return true;
 }
 
+///
+/// Process the queue with postponed add operations for LAG.
+///
+void TeamdCtlMgr::process_add_queue()
+{
+ std::vector<std::string> lag_names_to_add;
+ std::transform(m_lags_to_add.begin(), m_lags_to_add.end(), lag_names_to_add.begin(), [](auto pair) { return pair.first; });
+ for (const auto lag_name: lag_names_to_add)
+ {
+ bool result = try_add_lag(lag_name);
+ if (!result)
+ {
+ if (m_lags_to_add[lag_name] == TeamdCtlMgr::max_attempts_to_add)
+ {
+ SWSS_LOG_ERROR("Can't connect to teamd after %d attempts. LAG '%s'", TeamdCtlMgr::max_attempts_to_add, lag_name.c_str());
+ m_lags_to_add.erase(lag_name);
+ }
+ }
+ }
+}
+
 ///
 /// Get json dump from teamd for LAG interface with name lag_name
 /// @param lag_name a name for LAG interface

tlm_teamd/teamdctl_mgr.h

@@ -15,13 +15,18 @@ class TeamdCtlMgr
 public:
  TeamdCtlMgr() = default;
  ~TeamdCtlMgr();
- bool add_lag(const std::string & kag_name);
- bool remove_lag(const std::string & kag_name);
+ bool add_lag(const std::string & lag_name);
+ bool remove_lag(const std::string & lag_name);
+ void process_add_queue();
  TeamdCtlDump get_dump(const std::string & lag_name);
  TeamdCtlDumps get_dumps();
 
 private:
  bool has_key(const std::string & lag_name) const;
+ bool try_add_lag(const std::string & lag_name);
 
  std::unordered_map<std::string, struct teamdctl*> m_handlers;
+ std::unordered_map<std::string, int> m_lags_to_add;
+
+ const int max_attempts_to_add = 10;
 };

tlm_teamd/values_store.cpp

@@ -16,7 +16,7 @@ std::vector<std::string> ValuesStore::get_ports(json_t * root)
  int err = json_unpack(root, "{s:o}", "ports", &ports);
  if (err != 0)
  {
- throw std::runtime_error("Can't find 'ports' in the json dump object");
+ return result;
  }
 
  const char * key;