[Link Event Damping] Add RedisInterface plumbing for damping config

lib/ClientSai.cpp

@@ -247,6 +247,13 @@ sai_status_t ClientSai::set(
         return SAI_STATUS_FAILURE;
     }
 
+    if (RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
+    {
+        SWSS_LOG_ERROR("redis port extension attributes are not supported in CLIENT mode");
+
+        return SAI_STATUS_FAILURE;
+    }
+
     auto status = set(
             objectType,
             sai_serialize_object_id(objectId),

lib/RedisRemoteSaiInterface.cpp

@@ -666,6 +666,11 @@ sai_status_t RedisRemoteSaiInterface::set(
         return setRedisExtensionAttribute(objectType, objectId, attr);
     }
 
+    if (RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
+    {
+        return setRedisPortExtensionAttribute(objectType, objectId, attr);
+    }
+
     auto status = set(
             objectType,
             sai_serialize_object_id(objectId),
@@ -2201,6 +2206,112 @@ bool RedisRemoteSaiInterface::isRedisAttribute(
     return true;
 }
 
+bool RedisRemoteSaiInterface::isRedisPortAttribute(
+        _In_ sai_object_type_t objectType,
+        _In_ const sai_attribute_t* attr)
+{
+    SWSS_LOG_ENTER();
+
+    return objectType == SAI_OBJECT_TYPE_PORT
+        && attr != nullptr
+        && attr->id >= SAI_PORT_ATTR_CUSTOM_RANGE_START;
+}
+
+sai_status_t RedisRemoteSaiInterface::setRedisPortExtensionAttribute(
+        _In_ sai_object_type_t objectType,
+        _In_ sai_object_id_t objectId,
+        _In_ const sai_attribute_t *attr)
+{
+    SWSS_LOG_ENTER();
+
+    if (attr == nullptr)
+    {
+        SWSS_LOG_ERROR("attr pointer is null");
+
+        return SAI_STATUS_FAILURE;
+    }
+
+    switch ((sai_redis_port_attr_t)attr->id)
+    {
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGORITHM:
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGO_AIED_CONFIG:
+            return setLinkEventDampingConfig(objectId, attr);
+
+        default:
+            break;
+    }
+
+    SWSS_LOG_ERROR("unknown redis port extension attribute: %d", attr->id);
+
+    return SAI_STATUS_INVALID_PARAMETER;
+}
+
+sai_status_t RedisRemoteSaiInterface::setLinkEventDampingConfig(
+        _In_ sai_object_id_t objectId,
+        _In_ const sai_attribute_t *attr)
+{
+    SWSS_LOG_ENTER();
+
+    std::vector<swss::FieldValueTuple> entries;
+
+    std::string strAttrId = sai_serialize_redis_port_attr_id(
+            static_cast<sai_redis_port_attr_t>(attr->id));
+
+    switch ((sai_redis_port_attr_t)attr->id)
+    {
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGORITHM:
+        {
+            std::string strAttrValue = sai_serialize_redis_link_event_damping_algorithm(
+                    static_cast<sai_redis_link_event_damping_algorithm_t>(attr->value.s32));
+
+            entries.emplace_back(strAttrId, strAttrValue);
+            break;
+        }
+
+        case SAI_REDIS_PORT_ATTR_LINK_EVENT_DAMPING_ALGO_AIED_CONFIG:
+        {
+            auto *config = static_cast<const sai_redis_link_event_damping_algo_aied_config_t*>(attr->value.ptr);
+
+            if (config == nullptr)
+            {
+                SWSS_LOG_ERROR("link event damping AIED config pointer is null");
+
+                return SAI_STATUS_INVALID_PARAMETER;
+            }
+
+            std::string strAttrValue = sai_serialize_redis_link_event_damping_aied_config(*config);
+
+            entries.emplace_back(strAttrId, strAttrValue);
+            break;
+        }
+
+        default:
+
+            SWSS_LOG_ERROR("unknown damping config attribute: %d", attr->id);
+
+            return SAI_STATUS_INVALID_PARAMETER;
+    }
+
+    std::string key = sai_serialize_object_type(SAI_OBJECT_TYPE_PORT) + ":" + sai_serialize_object_id(objectId);
+
+    SWSS_LOG_DEBUG("damping config set key: %s", key.c_str());
+
+    m_communicationChannel->set(key, entries, REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET);
+
+    return waitForLinkEventDampingConfigResponse();
+}
+
+sai_status_t RedisRemoteSaiInterface::waitForLinkEventDampingConfigResponse()
+{
+    SWSS_LOG_ENTER();
+
+    swss::KeyOpFieldsValuesTuple kco;
+
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_RESPONSE, kco);
+
+    return status;
+}
+
 void RedisRemoteSaiInterface::handleNotification(
         _In_ const std::string &name,
         _In_ const std::string &serializedNotification,

lib/RedisRemoteSaiInterface.h

@@ -227,6 +227,10 @@ namespace sairedis
                     _In_ sai_object_id_t obejctType,
                     _In_ const sai_attribute_t* attr);
 
+            static bool isRedisPortAttribute(
+                    _In_ sai_object_type_t objectType,
+                    _In_ const sai_attribute_t* attr);
+
             sai_status_t setRedisAttribute(
                     _In_ sai_object_id_t switchId,
                     _In_ const sai_attribute_t* attr);
@@ -401,6 +405,17 @@ namespace sairedis
                     _In_ sai_object_id_t objectId,
                     _In_ const sai_attribute_t *attr);
 
+            sai_status_t setRedisPortExtensionAttribute(
+                    _In_ sai_object_type_t objectType,
+                    _In_ sai_object_id_t objectId,
+                    _In_ const sai_attribute_t *attr);
+
+            sai_status_t setLinkEventDampingConfig(
+                    _In_ sai_object_id_t objectId,
+                    _In_ const sai_attribute_t *attr);
+
+            sai_status_t waitForLinkEventDampingConfigResponse();
+
             bool isSaiS8ListValidString(
                     _In_ const sai_s8_list_t &s8list);
 

lib/Sai.cpp

@@ -249,6 +249,13 @@ sai_status_t Sai::set(
         return success ? SAI_STATUS_SUCCESS : SAI_STATUS_FAILURE;
     }
 
+    if (RedisRemoteSaiInterface::isRedisPortAttribute(objectType, attr))
+    {
+        REDIS_CHECK_CONTEXT(objectId);
+
+        return context->m_redisSai->set(objectType, objectId, attr);
+    }
+
     REDIS_CHECK_CONTEXT(objectId);
 
     return context->m_meta->set(objectType, objectId, attr);

lib/sairediscommon.h

@@ -64,6 +64,9 @@
 #define REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_QUERY "stats_st_capability_query"
 #define REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_RESPONSE "stats_st_capability_response"
 
+#define REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET          "link_event_damping_config_set"
+#define REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_RESPONSE     "link_event_damping_config_response"
+
 /**
  * @brief Redis virtual object id counter key name.
  *

syncd/Syncd.cpp

@@ -473,6 +473,9 @@ sai_status_t Syncd::processSingleEvent(
     if (op == REDIS_ASIC_STATE_COMMAND_OBJECT_TYPE_GET_AVAILABILITY_QUERY)
         return processObjectTypeGetAvailabilityQuery(kco);
 
+    if (op == REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_SET)
+        return processLinkEventDampingConfigSet(kco);
+
     if (op == REDIS_FLEX_COUNTER_COMMAND_START_POLL)
         return processFlexCounterEvent(key, SET_COMMAND, kfvFieldsValues(kco));
 
@@ -842,6 +845,30 @@ sai_status_t Syncd::processStatsStCapabilityQuery(
     return status;
 }
 
+sai_status_t Syncd::processLinkEventDampingConfigSet(
+        _In_ const swss::KeyOpFieldsValuesTuple &kco)
+{
+    SWSS_LOG_ENTER();
+
+    SWSS_LOG_NOTICE("link event damping config set not yet wired to SAI");
+
+    sendLinkEventDampingConfigResponse(SAI_STATUS_NOT_IMPLEMENTED);
+
+    return SAI_STATUS_NOT_IMPLEMENTED;
+}
+
+void Syncd::sendLinkEventDampingConfigResponse(
+        _In_ sai_status_t status)
+{
+    SWSS_LOG_ENTER();
+
+    std::string strStatus = sai_serialize_status(status);
+
+    SWSS_LOG_INFO("sending link event damping config response: %s", strStatus.c_str());
+
+    m_selectableChannel->set(strStatus, {}, REDIS_ASIC_STATE_COMMAND_DAMPING_CONFIG_RESPONSE);
+}
+
 sai_status_t Syncd::processFdbFlush(
         _In_ const swss::KeyOpFieldsValuesTuple &kco)
 {

syncd/Syncd.h

@@ -145,6 +145,9 @@ namespace syncd
             sai_status_t processStatsStCapabilityQuery(
                 _In_ const swss::KeyOpFieldsValuesTuple &kco);
 
+            sai_status_t processLinkEventDampingConfigSet(
+                    _In_ const swss::KeyOpFieldsValuesTuple &kco);
+
             sai_status_t processFdbFlush(
                     _In_ const swss::KeyOpFieldsValuesTuple &kco);
 
@@ -395,6 +398,9 @@ namespace syncd
             void sendNotifyResponse(
                     _In_ sai_status_t status);
 
+            void sendLinkEventDampingConfigResponse(
+                    _In_ sai_status_t status);
+
         private: // snoop get response oids
 
             void snoopGetResponse(

syncd/tests/Makefile.am

@@ -5,7 +5,7 @@ LDADD_GTEST = -L/usr/src/gtest -lgtest -lgtest_main
 bin_PROGRAMS = tests
 
 tests_SOURCES = \
-    main.cpp TestSyncdBrcm.cpp TestSyncdMlnx.cpp TestSyncdNvdaBf.cpp TestSyncdLib.cpp TestDisabledRedisClient.cpp
+    main.cpp TestSyncdBrcm.cpp TestSyncdMlnx.cpp TestSyncdNvdaBf.cpp TestSyncdLib.cpp TestDisabledRedisClient.cpp TestSyncdLinkEventDamping.cpp
 tests_CXXFLAGS = \
     $(DBGFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS_COMMON)
 tests_LDADD = \