TEST DO NOT MERGE 1509

Makefile.am

@@ -1,7 +1,7 @@
-SUBDIRS = meta lib vslib proxylib pyext
+SUBDIRS = meta lib vslib
 
 if SYNCD
-SUBDIRS += syncd saiplayer saidump saidiscovery saisdkdump saiasiccmp tests unittest
+SUBDIRS += syncd saiplayer unittest
 endif
 
 ACLOCAL_AMFLAGS = -I m4

debian/control

@@ -5,34 +5,6 @@ Priority: optional
 Build-Depends: debhelper (>= 12), autotools-dev, libzmq5-dev
 Standards-Version: 1.0.0
 
-Package: syncd
-Architecture: any
-Build-Profiles: <syncd !vs>
-Depends: ${misc:Pre-Depends}
-Recommends: ${shlibs:Depends}
-Conflicts: syncd-rpc, syncd-vs
-Description: This package contains sync daemon for SONiC project.
-  This sync daemon syncs the ASIC_DB in Redis database and the real ASIC via SAI.
-
-Package: syncd-rpc
-Architecture: any
-Build-Profiles: <syncd rpc !vs>
-Depends: ${misc:Pre-Depends}
-Recommends: ${shlibs:Depends}
-Conflicts: syncd, syncd-vs
-Description: This package contains sync daemon with rpc for SONiC project.
-  This sync daemon syncs the ASIC_DB in Redis database and the real ASIC via SAI.
-  This daemon contains saithrift rpc library for remote control of an ASIC.
-
-Package: syncd-vs
-Architecture: any
-Build-Profiles: <syncd !rpc vs>
-Depends: ${misc:Pre-Depends}
-Recommends: ${shlibs:Depends}
-Conflicts: syncd-rpc, syncd
-Description: This package contains sync daemon for SONiC project linked with virtual switch.
-  This sync daemon syncs the ASIC_DB in Redis database and the real ASIC via SAI.
-
 Package: libsairedis
 Architecture: any
 Depends: ${shlibs:Depends}, ${misc:Pre-Depends}
@@ -69,16 +41,3 @@ Depends: libsaimetadata (= ${binary:Version})
 Section: libdevel
 Description: This package contains development files for SAI-Metadata.
 
-Package: python-pysairedis
-Architecture: any
-Build-Profiles: <!nopython2>
-Depends: ${shlibs:Depends}, ${misc:Pre-Depends}
-Section: libs
-Description: This package contains Switch State Service sairedis Python2 library.
-
-Package: python3-pysairedis
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Pre-Depends}
-Section: libs
-Description: This package contains Switch State Service sairedis Python3 library.
-

lib/ClientServerSai.cpp

@@ -426,11 +426,18 @@ sai_status_t ClientServerSai::bulkGet(
         _In_ sai_bulk_op_error_mode_t mode,
         _Out_ sai_status_t *object_statuses)
 {
+    MUTEX();
     SWSS_LOG_ENTER();
+    REDIS_CHECK_API_INITIALIZED();
 
-    SWSS_LOG_ERROR("not implemented, FIXME");
-
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    return m_sai->bulkGet(
+            object_type,
+            object_count,
+            object_id,
+            attr_count,
+            attr_list,
+            mode,
+            object_statuses);
 }
 
 // BULK QUAD ENTRY

lib/Recorder.cpp

@@ -641,6 +641,40 @@ void Recorder::recordGenericGetResponse(
     recordLine("G|" + sai_serialize_status(status) + "|" + Globals::joinFieldValues(arguments));
 }
 
+void Recorder::recordBulkGenericGet(
+        _In_ const std::string& key,
+        _In_ const std::vector<swss::FieldValueTuple>& arguments)
+{
+    SWSS_LOG_ENTER();
+
+    std::string joined;
+
+    for (const auto &e: arguments)
+    {
+        joined += "||" + fvField(e) + "|" + fvValue(e);
+    }
+
+    // capital 'B' stands for Bulk GET operation. Note: 'G' already used for get response.
+
+    recordLine("B|" + key + joined);
+}
+
+void Recorder::recordBulkGenericGetResponse(
+        _In_ sai_status_t status,
+        _In_ const std::vector<swss::FieldValueTuple>& arguments)
+{
+    SWSS_LOG_ENTER();
+
+    std::string joined;
+
+    for (const auto &e: arguments)
+    {
+        joined += "||" + fvField(e) + "|" + fvValue(e);
+    }
+
+    recordLine("G|" + sai_serialize_status(status) + "|" + joined);
+}
+
 void Recorder::recordGenericGetStats(
         _In_ sai_object_type_t object_type,
         _In_ sai_object_id_t object_id,

lib/Recorder.h

@@ -247,6 +247,14 @@ namespace sairedis
                     _In_ uint32_t objectCount,
                     _In_ const sai_status_t *objectStatuses);
 
+            void recordBulkGenericGet(
+                    _In_ const std::string& key,
+                    _In_ const std::vector<swss::FieldValueTuple>& arguments);
+
+            void recordBulkGenericGetResponse(
+                    _In_ sai_status_t status,
+                    _In_ const std::vector<swss::FieldValueTuple>& arguments);
+
         public: // SAI query interface API
 
             void recordFlushFdbEntries(

lib/RedisRemoteSaiInterface.cpp

@@ -14,6 +14,8 @@
 #include "meta/PerformanceIntervalTimer.h"
 #include "meta/Globals.h"
 
+#include "swss/tokenize.h"
+
 #include "config.h"
 
 #include <inttypes.h>
@@ -1674,6 +1676,77 @@ sai_status_t RedisRemoteSaiInterface::waitForBulkResponse(
     return SAI_STATUS_SUCCESS;
 }
 
+sai_status_t RedisRemoteSaiInterface::waitForBulkGetResponse(
+        _In_ sai_object_type_t objectType,
+        _In_ uint32_t object_count,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _Out_ sai_status_t *object_statuses)
+{
+    SWSS_LOG_ENTER();
+
+    swss::KeyOpFieldsValuesTuple kco;
+
+    const auto status = m_communicationChannel->wait(REDIS_ASIC_STATE_COMMAND_GETRESPONSE, kco);
+
+    const auto &values = kfvFieldsValues(kco);
+
+    if (values.size() != object_count)
+    {
+        SWSS_LOG_THROW("wrong number of statuses, got %zu, expected %u", values.size(), object_count);
+    }
+
+    for (size_t idx = 0; idx < values.size(); idx++)
+    {
+        // field = status
+        // value = attrid=attrvalue|...
+
+        const auto& statusStr = fvField(values[idx]);
+        const auto& joined = fvValue(values[idx]);
+
+        const auto v = swss::tokenize(joined, '|');
+
+        std::vector<swss::FieldValueTuple> entries; // attributes per object id
+        entries.reserve(v.size());
+
+        for (size_t i = 0; i < v.size(); i++)
+        {
+            const std::string item = v.at(i);
+
+            auto start = item.find_first_of("=");
+
+            auto field = item.substr(0, start);
+            auto value = item.substr(start + 1);
+
+            entries.emplace_back(field, value);
+        }
+
+        // deserialize statuses for all objects
+        sai_deserialize_status(statusStr, object_statuses[idx]);
+
+        const auto objectStatus = object_statuses[idx];
+
+        if (objectStatus == SAI_STATUS_SUCCESS || objectStatus == SAI_STATUS_BUFFER_OVERFLOW)
+        {
+            const auto countOnly = (objectStatus == SAI_STATUS_BUFFER_OVERFLOW);
+
+            if (values.size() == 0)
+            {
+                SWSS_LOG_THROW("logic error, get response returned 0 values!, send api response or sync/async issue?");
+            }
+
+            SaiAttributeList list(objectType, entries, countOnly);
+
+            // no need for id fix since this is overflow
+            transfer_attributes(objectType, attr_count[idx], list.get_attr_list(), attr_list[idx], countOnly);
+        }
+    }
+
+    m_recorder->recordBulkGenericGetResponse(status, values);
+
+    return status;
+}
+
 sai_status_t RedisRemoteSaiInterface::bulkRemove(
         _In_ sai_object_type_t object_type,
         _In_ uint32_t object_count,
@@ -1764,9 +1837,67 @@ sai_status_t RedisRemoteSaiInterface::bulkGet(
 {
     SWSS_LOG_ENTER();
 
-    SWSS_LOG_ERROR("not implemented, FIXME");
+    std::vector<std::string> serializedObjectIds;
+    serializedObjectIds.reserve(object_count);
 
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    for (uint32_t idx = 0; idx < object_count; idx++)
+    {
+        serializedObjectIds.emplace_back(sai_serialize_object_id(object_id[idx]));
+    }
+
+    return bulkGet(object_type, serializedObjectIds, attr_count, attr_list, mode, object_statuses);
+}
+
+sai_status_t RedisRemoteSaiInterface::bulkGet(
+        _In_ sai_object_type_t object_type,
+        _In_ const std::vector<std::string> &serialized_object_ids,
+        _In_ const uint32_t *attr_count,
+        _Inout_ sai_attribute_t **attr_list,
+        _In_ sai_bulk_op_error_mode_t mode,
+        _Inout_ sai_status_t *object_statuses)
+{
+    SWSS_LOG_ENTER();
+
+    const auto serializedObjectType = sai_serialize_object_type(object_type);
+
+    std::vector<swss::FieldValueTuple> entries;
+    entries.reserve(serialized_object_ids.size());
+
+    for (size_t idx = 0; idx < serialized_object_ids.size(); idx++)
+    {
+        /*
+        * Since user may reuse buffers, then oid list buffers maybe not cleared
+        * and contain some garbage, let's clean them so we send all oids as null to
+        * syncd.
+        */
+
+        Utils::clearOidValues(object_type, attr_count[idx], attr_list[idx]);
+
+        const auto entry = SaiAttributeList::serialize_attr_list(object_type, attr_count[idx], attr_list[idx], false);
+
+        const auto strAttr = Globals::joinFieldValues(entry);
+
+        swss::FieldValueTuple fvt(serialized_object_ids[idx] , strAttr);
+
+        entries.push_back(fvt);
+    }
+
+    /*
+     * We are adding number of entries to actually add ':' to be compatible
+     * with previous
+     */
+
+    const auto key = serializedObjectType + ":" + std::to_string(entries.size());
+
+    m_communicationChannel->set(key, entries, REDIS_ASIC_STATE_COMMAND_BULK_GET);
+
+    m_recorder->recordBulkGenericGet(serializedObjectType, entries);
+
+    const auto object_count = static_cast<uint32_t>(serialized_object_ids.size());
+
+    const auto status = waitForBulkGetResponse(object_type, object_count, attr_count, attr_list, object_statuses);
+
+    return status;
 }
 
 sai_status_t RedisRemoteSaiInterface::bulkCreate(

lib/RedisRemoteSaiInterface.h

@@ -276,6 +276,14 @@ namespace sairedis
                     _In_ sai_bulk_op_error_mode_t mode,
                     _Out_ sai_status_t *object_statuses);
 
+            sai_status_t bulkGet(
+                    _In_ sai_object_type_t object_type,
+                    _In_ const std::vector<std::string> &serialized_object_ids,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _In_ sai_bulk_op_error_mode_t mode,
+                    _Out_ sai_status_t *object_statuses);
+
         private: // QUAD API response
 
             /**
@@ -317,6 +325,23 @@ namespace sairedis
                     _In_ uint32_t object_count,
                     _Out_ sai_status_t *object_statuses);
 
+            /**
+             * @brief Wait for bulk GET response.
+             *
+             * Will wait for response from syncd. Method only used for bulk
+             * GET object. If object status is SUCCESS all values will be deserialized
+             * and transferred to user buffers. If object status is BUFFER_OVERFLOW
+             * then all non list values will be transferred, but LIST objects
+             * will only transfer COUNT item of list, without touching user
+             * list at all.
+             */
+            sai_status_t waitForBulkGetResponse(
+                    _In_ sai_object_type_t objectType,
+                    _In_ uint32_t object_count,
+                    _In_ const uint32_t *attr_count,
+                    _Inout_ sai_attribute_t **attr_list,
+                    _Out_ sai_status_t *object_statuses);
+
         private: // stats API response
 
             sai_status_t waitForGetStatsResponse(

lib/Sai.cpp

@@ -524,11 +524,19 @@ sai_status_t Sai::bulkGet(
         _In_ sai_bulk_op_error_mode_t mode,
         _Out_ sai_status_t *object_statuses)
 {
+    MUTEX();
     SWSS_LOG_ENTER();
+    REDIS_CHECK_API_INITIALIZED();
+    REDIS_CHECK_CONTEXT(*object_id);
 
-    SWSS_LOG_ERROR("not implemented, FIXME");
-
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    return context->m_meta->bulkGet(
+            object_type,
+            object_count,
+            object_id,
+            attr_count,
+            attr_list,
+            mode,
+            object_statuses);
 }
 
 // BULK QUAD ENTRY

lib/ServerSai.cpp

@@ -452,9 +452,14 @@ sai_status_t ServerSai::bulkGet(
     SWSS_LOG_ENTER();
     REDIS_CHECK_API_INITIALIZED();
 
-    SWSS_LOG_ERROR("not implemented, FIXME");
-
-    return SAI_STATUS_NOT_IMPLEMENTED;
+    return m_sai->bulkGet(
+            object_type,
+            object_count,
+            object_id,
+            attr_count,
+            attr_list,
+            mode,
+            object_statuses);
 }
 
 // BULK QUAD ENTRY