[SAI]: Update SAI to support QUERY_STATS_ST_CAPABILITY and TAM (#1573)

lib/ClientSai.cpp

@@ -1060,6 +1060,58 @@ sai_status_t ClientSai::queryStatsCapability(
     return waitForQueryStatsCapabilityResponse(stats_capability);
 }
 
+sai_status_t ClientSai::waitForQueryStatsCapabilityResponse(
+        _Inout_ sai_stat_capability_list_t* stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    swss::KeyOpFieldsValuesTuple kco;
+
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_CAPABILITY_RESPONSE, kco);
+
+    if (status == SAI_STATUS_SUCCESS)
+    {
+        const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+        if (values.size() != 3)
+        {
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 3 value, received %zu", values.size());
+
+            return SAI_STATUS_FAILURE;
+        }
+
+        const std::string &stat_enum_str = fvValue(values[0]);
+        const std::string &stat_modes_str = fvValue(values[1]);
+        const uint32_t num_capabilities = std::stoi(fvValue(values[2]));
+
+        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', count = %d",
+                       stat_enum_str.c_str(), stat_modes_str.c_str(), num_capabilities);
+
+        stats_capability->count = num_capabilities;
+
+        sai_deserialize_stats_capability_list(stats_capability, stat_enum_str, stat_modes_str);
+    }
+    else if (status ==  SAI_STATUS_BUFFER_OVERFLOW)
+    {
+        const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
+
+        if (values.size() != 1)
+        {
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 1 value, received %zu", values.size());
+
+            return SAI_STATUS_FAILURE;
+        }
+
+        const uint32_t num_capabilities = std::stoi(fvValue(values[0]));
+
+        SWSS_LOG_DEBUG("Received payload: count = %u", num_capabilities);
+
+        stats_capability->count = num_capabilities;
+    }
+
+    return status;
+}
+
 sai_status_t ClientSai::queryStatsStCapability(
     _In_ sai_object_id_t switchId,
     _In_ sai_object_type_t objectType,
@@ -1078,43 +1130,71 @@ sai_status_t ClientSai::queryStatsStCapability(
         return SAI_STATUS_INVALID_PARAMETER;
     }
 
-    // TODO: Fix me
+    if (stats_capability && stats_capability->list && (stats_capability->count))
+    {
+        // clear input list, since we use serialize to transfer values
+        for (uint32_t idx = 0; idx < stats_capability->count; idx++)
+        {
+            stats_capability->list[idx].capability.stat_enum = 0;
+            stats_capability->list[idx].capability.stat_modes = 0;
+            stats_capability->list[idx].minimal_polling_interval = 0;
+        }
+    }
 
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    const std::string listSize = std::to_string(stats_capability->count);
+
+    const std::vector<swss::FieldValueTuple> entry =
+        {
+            swss::FieldValueTuple("OBJECT_TYPE", objectTypeStr),
+            swss::FieldValueTuple("LIST_SIZE", listSize)};
+
+    SWSS_LOG_DEBUG(
+        "Query arguments: switch %s, object type: %s, count: %s",
+        switchIdStr.c_str(),
+        objectTypeStr.c_str(),
+        listSize.c_str());
+
+    // This query will not put any data into the ASIC view, just into the
+    // message queue
+
+    m_communicationChannel->set(switchIdStr, entry, REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_QUERY);
+
+    return waitForQueryStatsStCapabilityResponse(stats_capability);
 }
 
-sai_status_t ClientSai::waitForQueryStatsCapabilityResponse(
-        _Inout_ sai_stat_capability_list_t* stats_capability)
+sai_status_t ClientSai::waitForQueryStatsStCapabilityResponse(
+    _Inout_ sai_stat_st_capability_list_t *stats_capability)
 {
     SWSS_LOG_ENTER();
 
     swss::KeyOpFieldsValuesTuple kco;
 
-    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_CAPABILITY_RESPONSE, kco);
+    auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_STATS_ST_CAPABILITY_RESPONSE, kco);
 
     if (status == SAI_STATUS_SUCCESS)
     {
         const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
 
-        if (values.size() != 3)
+        if (values.size() != 4)
         {
-            SWSS_LOG_ERROR("Invalid response from syncd: expected 3 value, received %zu", values.size());
+            SWSS_LOG_ERROR("Invalid response from syncd: expected 4 value, received %zu", values.size());
 
             return SAI_STATUS_FAILURE;
         }
 
         const std::string &stat_enum_str = fvValue(values[0]);
         const std::string &stat_modes_str = fvValue(values[1]);
-        const uint32_t num_capabilities = std::stoi(fvValue(values[2]));
+        const std::string &polling_interval_str = fvValue(values[2]);
+        const uint32_t num_capabilities = std::stoi(fvValue(values[3]));
 
-        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', count = %d",
-                       stat_enum_str.c_str(), stat_modes_str.c_str(), num_capabilities);
+        SWSS_LOG_DEBUG("Received payload: stat_enums = '%s', stat_modes = '%s', minimal_polling_intervals = '%s' count = %d",
+                       stat_enum_str.c_str(), stat_modes_str.c_str(), polling_interval_str.c_str(), num_capabilities);
 
         stats_capability->count = num_capabilities;
 
-        sai_deserialize_stats_capability_list(stats_capability, stat_enum_str, stat_modes_str);
+        sai_deserialize_stats_st_capability_list(stats_capability, stat_enum_str, stat_modes_str, polling_interval_str);
     }
-    else if (status ==  SAI_STATUS_BUFFER_OVERFLOW)
+    else if (status == SAI_STATUS_BUFFER_OVERFLOW)
     {
         const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
 

lib/ClientSai.h

@@ -305,7 +305,10 @@ namespace sairedis
             sai_status_t waitForQueryStatsCapabilityResponse(
                     _Inout_ sai_stat_capability_list_t* stats_capability);
 
-        private:
+            sai_status_t waitForQueryStatsStCapabilityResponse(
+                _Inout_ sai_stat_st_capability_list_t *stats_capability);
+
+    private:
 
             void handleNotification(
                     _In_ const std::string &name,

lib/Recorder.cpp

@@ -388,6 +388,24 @@ void Recorder::recordQueryStatsCapabilityResponse(
     recordLine("Q|stats_capability|" + sai_serialize_status(status) + "|" + arguments);
 }
 
+void Recorder::recordQueryStatsStCapability(
+    _In_ const std::string &key,
+    _In_ const std::vector<swss::FieldValueTuple> &arguments)
+{
+    SWSS_LOG_ENTER();
+
+    recordLine("q|stats_st_capability|" + key + "|" + Globals::joinFieldValues(arguments));
+}
+
+void Recorder::recordQueryStatsStCapabilityResponse(
+    _In_ sai_status_t status,
+    _In_ const std::string &arguments)
+{
+    SWSS_LOG_ENTER();
+
+    recordLine("Q|stats_st_capability|" + sai_serialize_status(status) + "|" + arguments);
+}
+
 void Recorder::recordNotifySyncd(
         _In_ const std::string& key)
 {
@@ -1217,6 +1235,66 @@ void Recorder::recordQueryStatsCapabilityResponse(
     recordQueryStatsCapabilityResponse(status, str_stats_list);
 }
 
+void Recorder::recordQueryStatsStCapability(
+    _In_ sai_object_id_t switch_id,
+    _In_ sai_object_type_t object_type,
+    _Inout_ sai_stat_st_capability_list_t *stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    auto key = sai_serialize_object_type(SAI_OBJECT_TYPE_SWITCH) + ":" + sai_serialize_object_id(switch_id);
+
+    auto object_type_str = sai_serialize_object_type(object_type);
+    const std::string list_size = std::to_string(stats_capability->count);
+    const std::vector<swss::FieldValueTuple> values =
+        {
+            swss::FieldValueTuple("OBJECT_TYPE", object_type_str),
+            swss::FieldValueTuple("LIST_SIZE", list_size)};
+
+    SWSS_LOG_DEBUG("Query arguments: switch %s, object_type: %s, count: %s",
+                   key.c_str(),
+                   object_type_str.c_str(),
+                   list_size.c_str());
+
+    recordQueryStatsStCapability(key, values);
+}
+
+void Recorder::recordQueryStatsStCapabilityResponse(
+    _In_ sai_status_t status,
+    _In_ sai_object_type_t objectType,
+    _In_ const sai_stat_st_capability_list_t *stats_capability)
+{
+    SWSS_LOG_ENTER();
+
+    std::string str_stats_list;
+
+    auto meta = sai_metadata_get_object_type_info(objectType);
+
+    if (meta == NULL)
+    {
+        SWSS_LOG_ERROR("Failed to find object metadata: object type %s",
+                       sai_serialize_object_type(objectType).c_str());
+
+        return;
+    }
+
+    if (meta->statenum == NULL)
+    {
+        SWSS_LOG_ERROR("%s does not support stats", meta->objecttypename);
+
+        return;
+    }
+
+    bool countOnly = (status == SAI_STATUS_BUFFER_OVERFLOW);
+
+    if (status == SAI_STATUS_SUCCESS || status == SAI_STATUS_BUFFER_OVERFLOW)
+    {
+        str_stats_list = sai_serialize_stats_st_capability_list(*stats_capability, meta->statenum, countOnly);
+    }
+
+    recordQueryStatsStCapabilityResponse(status, str_stats_list);
+}
+
 void Recorder::recordNotifySyncd(
         _In_ sai_object_id_t switchId,
         _In_ sai_redis_notify_syncd_t redisNotifySyncd)

lib/Recorder.h

@@ -316,6 +316,16 @@ namespace sairedis
                     _In_ sai_object_type_t objectType,
                     _In_ const sai_stat_capability_list_t *stats_capability);
 
+            void recordQueryStatsStCapability(
+                _In_ sai_object_id_t switch_id,
+                _In_ sai_object_type_t object_type,
+                _Inout_ sai_stat_st_capability_list_t *stats_capability);
+
+            void recordQueryStatsStCapabilityResponse(
+                _In_ sai_status_t status,
+                _In_ sai_object_type_t objectType,
+                _In_ const sai_stat_st_capability_list_t *stats_capability);
+
             // TODO move to private
             void recordQueryAttributeCapability(
                     _In_ const std::string& key,
@@ -349,7 +359,15 @@ namespace sairedis
                     _In_ sai_status_t status,
                     _In_ const std::string& arguments);
 
-        public: // SAI notifications
+            void recordQueryStatsStCapability(
+                    _In_ const std::string &key,
+                    _In_ const std::vector<swss::FieldValueTuple> &arguments);
+
+            void recordQueryStatsStCapabilityResponse(
+                    _In_ sai_status_t status,
+                    _In_ const std::string &arguments);
+
+    public: // SAI notifications
 
             void recordNotification(
                     _In_ const std::string &name,