orchagent: Adding QosOrch and BufferOrch classes

* Class BufferOrch to handle buffer configuration
* refactored Orch based class to contain common functions from QosOrch
and BufferOrch
* Class QosOrch
*   serialization for qos
*   qos functionality, including scheduler group processing

* main.cpp
*    changed log level DEBUG back to INFO
* portsqosorch.cpp, Port::getQueue
* portsqosorch.cpp, Port::getPG

* Samples
*  Added QOS and Buffer related configuration samples under swssconfig/sample.

Author: Hrachya Mughnetsyan

orchagent/Makefile.am

@@ -10,7 +10,7 @@ else
 DBGFLAGS = -g
 endif
 
-orchagent_SOURCES = main.cpp orchdaemon.cpp orch.cpp routeorch.cpp neighorch.cpp intfsorch.cpp portsorch.cpp
+orchagent_SOURCES = main.cpp orchdaemon.cpp orch.cpp routeorch.cpp neighorch.cpp intfsorch.cpp portsorch.cpp qosorch.cpp bufferorch.cpp
 
 orchagent_CFLAGS = $(DBGFLAGS) $(AM_CFLAGS) $(CFLAGS_COMMON) $(CFLAGS_SAI)
 orchagent_CPPFLAGS = $(DBGFLAGS) $(AM_CFLAGS) $(CFLAGS_COMMON) $(CFLAGS_SAI)

orchagent/bufferorch.cpp

@@ -0,0 +1,50 @@
+#ifndef SWSS_BUFFORCH_H
+#define SWSS_BUFFORCH_H
+
+#include <map>
+#include "orch.h"
+#include "portsorch.h"
+
+const std::string buffer_size_field_name         = "size";
+const std::string buffer_pool_type_field_name    = "type";
+const std::string buffer_pool_mode_field_name    = "mode";
+const std::string buffer_pool_field_name         = "pool";
+const std::string buffer_xon_field_name          = "xon";
+const std::string buffer_xoff_field_name         = "xoff";
+const std::string buffer_dynamic_th_field_name   = "dynamic_th";
+const std::string buffer_static_th_field_name    = "static_th";
+const std::string buffer_profile_field_name      = "profile";
+const std::string buffer_value_ingress           = "ingress";
+const std::string buffer_value_egress            = "egress";
+const std::string buffer_pool_mode_dynamic_value = "dynamic";
+const std::string buffer_pool_mode_static_value  = "static";
+const std::string range_specifier                = "-";
+const std::string buffer_profile_list_field_name = "profile_list";
+const std::string comma                          = ",";
+
+class BufferOrch : public Orch
+{
+public:
+    BufferOrch(DBConnector *db, vector<string> &tableNames, PortsOrch *portsOrch);
+    static type_map m_buffer_type_maps;
+private:
+    typedef task_process_status (BufferOrch::*buffer_table_handler)(Consumer& consumer);
+    typedef std::map<std::string, buffer_table_handler> buffer_table_handler_map;
+    typedef std::pair<string, buffer_table_handler> buffer_handler_pair;
+
+    virtual void doTask(Consumer& consumer);
+    void initTableHandlers();
+    task_process_status processBufferPool(Consumer &consumer);
+    task_process_status processBufferProfile(Consumer &consumer);
+    task_process_status processQueue(Consumer &consumer);
+    task_process_status processPriorityGroup(Consumer &consumer);
+    task_process_status processIngressBufferProfileList(Consumer &consumer);
+    task_process_status processEgressBufferProfileList(Consumer &consumer);
+    bool parseIndexRange(const string &input, sai_uint32_t &range_low, sai_uint32_t &range_high);
+    bool parseNameArray(const string &input, vector<string> &port_names);
+private:
+    PortsOrch *m_portsOrch;
+    buffer_table_handler_map m_bufferHandlerMap;
+};
+#endif /* SWSS_BUFFORCH_H */
+

orchagent/bufferorch.h

@@ -31,6 +31,12 @@ sai_next_hop_api_t*         sai_next_hop_api;
 sai_next_hop_group_api_t*   sai_next_hop_group_api;
 sai_route_api_t*            sai_route_api;
 sai_lag_api_t*              sai_lag_api;
+sai_queue_api_t*            sai_queue_api;
+sai_scheduler_api_t*        sai_scheduler_api;
+sai_scheduler_group_api_t*  sai_scheduler_group_api;
+sai_wred_api_t*             sai_wred_api;
+sai_qos_map_api_t*          sai_qos_map_api;
+sai_buffer_api_t*           sai_buffer_api;
 
 map<string, string> gProfileMap;
 sai_object_id_t gVirtualRouterId;
@@ -84,7 +90,13 @@ void initSaiApi()
     sai_api_query(SAI_API_NEXT_HOP_GROUP,       (void **)&sai_next_hop_group_api);
     sai_api_query(SAI_API_ROUTE,                (void **)&sai_route_api);
     sai_api_query(SAI_API_LAG,                  (void **)&sai_lag_api);
-
+    sai_api_query(SAI_API_QUEUE,                (void **)&sai_queue_api);
+    sai_api_query(SAI_API_SCHEDULER,            (void **)&sai_scheduler_api);
+    sai_api_query(SAI_API_WRED,                 (void **)&sai_wred_api);
+    sai_api_query(SAI_API_QOS_MAPS,             (void **)&sai_qos_map_api);
+    sai_api_query(SAI_API_BUFFERS,              (void **)&sai_buffer_api);
+    sai_api_query(SAI_API_SCHEDULER_GROUP,      (void **)&sai_scheduler_group_api);
+    
     sai_log_set(SAI_API_SWITCH,                 SAI_LOG_NOTICE);
     sai_log_set(SAI_API_VIRTUAL_ROUTER,         SAI_LOG_NOTICE);
     sai_log_set(SAI_API_PORT,                   SAI_LOG_NOTICE);
@@ -96,6 +108,12 @@ void initSaiApi()
     sai_log_set(SAI_API_NEXT_HOP_GROUP,         SAI_LOG_NOTICE);
     sai_log_set(SAI_API_ROUTE,                  SAI_LOG_NOTICE);
     sai_log_set(SAI_API_LAG,                    SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_QUEUE,                  SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_SCHEDULER,              SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_WRED,                   SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_QOS_MAPS,               SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_BUFFERS,                SAI_LOG_NOTICE);
+    sai_log_set(SAI_API_SCHEDULER_GROUP,        SAI_LOG_NOTICE);    
 }
 
 void initDiagShell()

orchagent/main.cpp

@@ -1,6 +1,9 @@
 #include "orch.h"
 #include "logger.h"
 
+#include <sstream>
+#include <iostream>
+
 using namespace swss;
 
 Orch::Orch(DBConnector *db, string tableName) :
@@ -13,7 +16,8 @@ Orch::Orch(DBConnector *db, string tableName) :
 Orch::Orch(DBConnector *db, vector<string> &tableNames) :
     m_db(db)
 {
-    for( auto it = tableNames.begin(); it != tableNames.end(); it++) {
+    for( auto it = tableNames.begin(); it != tableNames.end(); it++)
+    {
         Consumer consumer(new ConsumerTable(m_db, *it));
         m_consumerMap.insert(ConsumerMapPair(*it, consumer));
     }
@@ -22,9 +26,8 @@ Orch::Orch(DBConnector *db, vector<string> &tableNames) :
 Orch::~Orch()
 {
     delete(m_db);
-    for(auto it : m_consumerMap) {
+    for(auto it : m_consumerMap)
         delete it.second.m_consumer;
-    }
 }
 
 std::vector<Selectable *> Orch::getSelectables()
@@ -48,10 +51,21 @@ bool Orch::hasSelectable(ConsumerTable *selectable) const
     return false;
 }
 
+void Orch::dumpTuple(Consumer &consumer, KeyOpFieldsValuesTuple &tuple)
+{
+    string debug_msg = "Full table content: " + consumer.m_consumer->getTableName() + " key : " + kfvKey(tuple) + " op : "  + kfvOp(tuple);
+    for (auto i = kfvFieldsValues(tuple).begin(); i != kfvFieldsValues(tuple).end(); i++)
+    {
+        debug_msg += " " + fvField(*i) + " : " + fvValue(*i);
+    }
+    SWSS_LOG_DEBUG("%s\n", debug_msg.c_str());
+}
+
 bool Orch::execute(string tableName)
 {
     auto consumer_it = m_consumerMap.find(tableName);
-    if(consumer_it == m_consumerMap.end()) {
+    if(consumer_it == m_consumerMap.end())
+    {
         SWSS_LOG_ERROR("Unrecognized tableName:%s\n", tableName.c_str());
         return false;
     }
@@ -62,16 +76,10 @@ bool Orch::execute(string tableName)
 
     string key = kfvKey(new_data);
     string op  = kfvOp(new_data);
-
-#ifdef DEBUG
-    string debug = "Table : " + consumer.m_consumer.getTableName() + " key : " + kfvKey(new_data) + " op : "  + kfvOp(new_data);
-    for (auto i = kfvFieldsValues(new_data).begin(); i != kfvFieldsValues(new_data).end(); i++)
-        debug += " " + fvField(*i) + " : " + fvValue(*i);
-    SWSS_LOG_DEBUG("%s\n", debug.c_str());
-#endif
+    dumpTuple(consumer, new_data);
 
     /* If a new task comes or if a DEL task comes, we directly put it into consumer.m_toSync map */
-    if ( consumer.m_toSync.find(key) == consumer.m_toSync.end() || op == DEL_COMMAND)
+    if( consumer.m_toSync.find(key) == consumer.m_toSync.end() || op == DEL_COMMAND)
     {
        consumer.m_toSync[key] = new_data;
     }
@@ -93,7 +101,7 @@ bool Orch::execute(string tableName)
             while (iu != existing_values.end())
             {
                 string ofield = fvField(*iu);
-                if (field == ofield)
+                if(field == ofield)
                     iu = existing_values.erase(iu);
                 else
                     iu++;
@@ -103,7 +111,119 @@ bool Orch::execute(string tableName)
         consumer.m_toSync[key] = KeyOpFieldsValuesTuple(key, op, existing_values);
     }
 
-    if (!consumer.m_toSync.empty())
+    if(!consumer.m_toSync.empty())
+        doTask(consumer);
+
+    return true;
+}
+bool Orch::tokenizeString(string str, const string &separator, vector<string> &tokens)
+{
+    SWSS_LOG_ENTER();
+    if(0 == separator.size())
+    {
+        SWSS_LOG_ERROR("Invalid separator passed in:%s\n", separator.c_str());
+        return false;
+    }
+    if(string::npos == str.find(separator))
+    {
+        SWSS_LOG_ERROR("Specified separator:%s not found in input:%s\n", separator.c_str(), str.c_str());
+        return false;
+    }
+    istringstream ss(str);
+    string tmp;
+    while (getline(ss, tmp, separator[0]))
+    {
+        SWSS_LOG_DEBUG("extracted token:%s", tmp.c_str());
+        tokens.push_back(tmp);
+    }
+    return true;
+}
+
+/*
+- Validates reference has proper format which is [table_name:object_name]
+- validates table_name exists
+- validates object with object_name exists
+*/
+bool Orch::parseReference(type_map &type_maps, string &ref_in, string &type_name, string &object_name)
+{
+    SWSS_LOG_ENTER();
+    SWSS_LOG_DEBUG("input:%s", ref_in.c_str());
+    if(ref_in.size() < 3)
+    {
+        SWSS_LOG_ERROR("invalid reference received:%s\n", ref_in.c_str());
+        return false;
+    }
+    if((ref_in[0] != ref_start) && (ref_in[ref_in.size()-1] != ref_end))
+    {
+        SWSS_LOG_ERROR("malformed reference:%s. Must be surrounded by [ ]\n", ref_in.c_str());
+        return false;
+    }
+    string ref_content = ref_in.substr(1, ref_in.size() - 2);
+    vector<string> tokens;
+    if(!tokenizeString(ref_content, delimiter, tokens))
+    {
+        return false;
+    }
+    if(tokens.size() != 2)
+    {
+        SWSS_LOG_ERROR("malformed reference:%s. Must contain 2 tokens\n", ref_content.c_str());
+        return false;
+    }
+    auto type_it = type_maps.find(tokens[0]);
+    if(type_it == type_maps.end())
+    {
+        SWSS_LOG_ERROR("not recognized type:%s\n", tokens[0].c_str());
+        return false;
+    }
+    auto obj_map = type_maps[tokens[0]];
+    auto obj_it = obj_map->find(tokens[1]);
+    if(obj_it == obj_map->end())
+    {
+        SWSS_LOG_ERROR("map:%s does not contain object with name:%s\n", tokens[0].c_str(), tokens[1].c_str());
+        return false;
+    }
+    type_name   = tokens[0];
+    object_name = tokens[1];
+    SWSS_LOG_DEBUG("parsed: type_name:%s, object_name:%s", type_name.c_str(), object_name.c_str());
+    return true;
+}
+
+ref_resolve_status Orch::resolveFieldRefValue(
+    type_map                &type_maps,
+    const string            &field_name,
+    KeyOpFieldsValuesTuple  &tuple,
+    sai_object_id_t         &sai_object)
+{
+    SWSS_LOG_ENTER();
+    size_t count = 0;
+    for (auto i = kfvFieldsValues(tuple).begin(); i != kfvFieldsValues(tuple).end(); i++)
+    {
+        if(fvField(*i) == field_name)
+        {
+            SWSS_LOG_DEBUG("field:%s, value:%s", fvField(*i).c_str(), fvValue(*i).c_str());
+            if(count > 1)
+            {
+                SWSS_LOG_ERROR("Singleton field with name:%s must have only 1 instance, actual count:%d\n", field_name.c_str(), count);
+                return ref_resolve_status::multiple_instances;
+            }
+            string ref_type_name, object_name;
+            if(!parseReference(type_maps, fvValue(*i), ref_type_name, object_name))
+            {
+                return ref_resolve_status::not_resolved;
+            }
+            sai_object = (*(type_maps[ref_type_name]))[object_name];
+            count++;
+        }
+    }
+    if(0 == count)
+    {
+        SWSS_LOG_NOTICE("field with name:%s not found\n", field_name.c_str());
+        return ref_resolve_status::field_not_found;
+    }
+    return ref_resolve_status::success;
+}
+
+    if(!consumer.m_toSync.empty())
         doTask(consumer);
 
     return true;
@@ -113,7 +233,63 @@ void Orch::doTask()
 {
     for(auto it : m_consumerMap)
     {
-        if (!it.second.m_toSync.empty())
+        if(!it.second.m_toSync.empty())
             doTask(it.second);
     }
-}
+}
+
+// example: [BUFFER_PROFILE_TABLE:e_port.profile0],[BUFFER_PROFILE_TABLE:e_port.profile1]
+ref_resolve_status Orch::resolveFieldRefArray(
+    type_map                    &type_maps,
+    const string                &field_name,
+    KeyOpFieldsValuesTuple      &tuple,
+    vector<sai_object_id_t>     &sai_object_arr)
+{
+    SWSS_LOG_ENTER();
+    size_t count = 0;
+    sai_object_arr.clear();
+    for (auto i = kfvFieldsValues(tuple).begin(); i != kfvFieldsValues(tuple).end(); i++)
+    {
+        if(fvField(*i) == field_name)
+        {
+            if(count > 1)
+            {
+                SWSS_LOG_ERROR("Singleton field with name:%s must have only 1 instance, actual count:%d\n", field_name.c_str(), count);
+                return ref_resolve_status::multiple_instances;
+            }
+            string ref_type_name, object_name;
+            string list = fvValue(*i);
+            vector<string> list_items;
+            if(list.find(list_item_delimiter) != string::npos)
+            {
+                if(!tokenizeString(list, list_item_delimiter, list_items))
+                {
+                    SWSS_LOG_ERROR("Failed to tokenize buffer profile list:%s\n", list.c_str());
+                    return ref_resolve_status::failure;
+                }
+            }
+            else
+            {
+                list_items.push_back(list);
+            }
+            for (size_t ind = 0; ind < list_items.size(); ind++)
+            {
+                if(!parseReference(type_maps, list_items[ind], ref_type_name, object_name))
+                {
+                    SWSS_LOG_ERROR("Failed to parse profile reference:%s\n", list_items[ind].c_str());
+                    return ref_resolve_status::not_resolved;
+                }
+                sai_object_id_t sai_obj = (*(type_maps[ref_type_name]))[object_name];
+                SWSS_LOG_DEBUG("Resolved to sai_object:0x%llx, type:%s, name:%s", sai_obj, ref_type_name.c_str(), object_name.c_str());
+                sai_object_arr.push_back(sai_obj);
+            }
+            count++;
+        }
+    }
+    if(0 == count)
+    {
+        SWSS_LOG_NOTICE("field with name:%s not found\n", field_name.c_str());
+        return ref_resolve_status::field_not_found;
+    }
+    return ref_resolve_status::success;
+}