Producer/Consumer table binary support

common/Makefile.am

@@ -35,6 +35,7 @@ common_libswsscommon_la_SOURCES = \
     common/producerstatetable.cpp    \
     common/zmqproducerstatetable.cpp \
     common/rediscommand.cpp          \
+    common/redisstring.cpp           \
     common/redistran.cpp             \
     common/redisselect.cpp           \
     common/select.cpp                \

common/consumerstatetable.cpp

@@ -68,16 +68,16 @@ void ConsumerStateTable::pops(std::deque<KeyOpFieldsValuesTuple> &vkco, const st
 
         auto& ctx = ctx0->element[ie];
         assert(ctx->element[0]->type == REDIS_REPLY_STRING);
-        std::string key = ctx->element[0]->str;
+        std::string key(ctx->element[0]->str, ctx->element[0]->len);
         kfvKey(kco) = key;
 
         assert(ctx->element[1]->type == REDIS_REPLY_ARRAY);
         auto ctx1 = ctx->element[1];
         for (size_t i = 0; i < ctx1->elements / 2; i++)
         {
             FieldValueTuple e;
-            fvField(e) = ctx1->element[i * 2]->str;
-            fvValue(e) = ctx1->element[i * 2 + 1]->str;
+            fvField(e).assign(ctx1->element[i * 2]->str, ctx1->element[i * 2]->len);
+            fvValue(e).assign(ctx1->element[i * 2 + 1]->str, ctx1->element[i * 2 + 1]->len);
             values.push_back(e);
         }
 

common/luatable.cpp

@@ -54,13 +54,9 @@ bool LuaTable::get(const vector<string> &luaKeys, vector<FieldValueTuple> &value
         args.emplace_back(v);
     }
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     RedisReply r(m_db.get(), command, REDIS_REPLY_ARRAY);
     redisReply *reply = r.getContext();
 
@@ -109,13 +105,9 @@ bool LuaTable::hget(const vector<string> &luaKeys, const string &field, string &
         args.emplace_back(v);
     }
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     RedisReply r(m_db.get(), command);
     redisReply *reply = r.getContext();
 

common/producerstatetable.cpp

@@ -134,13 +134,9 @@ void ProducerStateTable::set(const string &key, const vector<FieldValueTuple> &v
         args.emplace_back(fvValue(iv));
     }
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     m_pipe->push(command, REDIS_REPLY_NIL);
     if (!m_buffered)
     {
@@ -171,13 +167,9 @@ void ProducerStateTable::del(const string &key, const string &op /*= DEL_COMMAND
     args.emplace_back("''");
     args.emplace_back("''");
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     m_pipe->push(command, REDIS_REPLY_NIL);
     if (!m_buffered)
     {
@@ -224,13 +216,9 @@ void ProducerStateTable::set(const std::vector<KeyOpFieldsValuesTuple>& values)
         }
     }
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     m_pipe->push(command, REDIS_REPLY_NIL);
     if (!m_buffered)
     {
@@ -265,13 +253,9 @@ void ProducerStateTable::del(const std::vector<std::string>& keys)
     }
     args.emplace_back("G");
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     m_pipe->push(command, REDIS_REPLY_NIL);
     if (!m_buffered)
     {
@@ -307,13 +291,9 @@ void ProducerStateTable::clear()
     args.emplace_back(getStateHashPrefix() + getTableName());
     args.emplace_back(getDelKeySetName());
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand cmd;
-    cmd.formatArgv((int)args1.size(), &args1[0], NULL);
+    cmd.format(args);
     m_pipe->push(cmd, REDIS_REPLY_NIL);
     m_pipe->flush();
 }
@@ -466,13 +446,9 @@ void ProducerStateTable::apply_temp_view()
         SWSS_LOG_DEBUG("apply_view.lua is called with following argument list: %s", ss.str().c_str());
     }
 
-    // Transform data structure
-    vector<const char *> args1;
-    transform(args.begin(), args.end(), back_inserter(args1), [](const string &s) { return s.c_str(); } );
-
     // Invoke redis command
     RedisCommand command;
-    command.formatArgv((int)args1.size(), &args1[0], NULL);
+    command.format(args);
     m_pipe->push(command, REDIS_REPLY_NIL);
     m_pipe->flush();
 

common/redisapi.h

@@ -83,16 +83,8 @@ static inline std::set<std::string> runRedisScript(RedisContext &ctx, const std:
     args.insert(args.end(), argv.begin(), argv.end());
     args.push_back("''");
 
-    // Convert to vector of char *
-    std::vector<const char *> c_args;
-    transform(
-            args.begin(),
-            args.end(),
-            std::back_inserter(c_args),
-            [](const std::string& s) { return s.c_str(); } );
-
     RedisCommand command;
-    command.formatArgv(static_cast<int>(c_args.size()), c_args.data(), NULL);
+    command.format(args);
 
     std::set<std::string> ret;
     try

common/rediscommand.cpp

@@ -7,23 +7,16 @@ using namespace std;
 namespace swss {
 
 RedisCommand::RedisCommand()
- : temp(NULL)
 {
 }
 
 RedisCommand::~RedisCommand()
 {
-    redisFreeCommand(temp);
 }
 
 void RedisCommand::format(const char *fmt, ...)
 {
-    if (temp != nullptr)
-    {
-        redisFreeCommand(temp);
-        temp = nullptr;
-    }
-
+    char *temp = nullptr;
     va_list ap;
     va_start(ap, fmt);
     int len = redisvFormatCommand(&temp, fmt, ap);
@@ -33,30 +26,29 @@ void RedisCommand::format(const char *fmt, ...)
     } else if (len == -2) {
         throw std::invalid_argument("fmt");
     }
+    m_str.reset(temp, len);
 }
 
 void RedisCommand::formatArgv(int argc, const char **argv, const size_t *argvlen)
 {
-    if (temp != nullptr)
-    {
-        redisFreeCommand(temp);
-        temp = nullptr;
-    }
-
+    char *temp = nullptr;
     int len = redisFormatCommandArgv(&temp, argc, argv, argvlen);
     if (len == -1) {
         throw std::bad_alloc();
     }
+    m_str.reset(temp, len);
 }
 
 void RedisCommand::format(const vector<string> &commands)
 {
     vector<const char*> args;
+    vector<size_t> lens;
     for (auto& command : commands)
     {
         args.push_back(command.c_str());
+        lens.push_back(command.size());
     }
-    formatArgv(static_cast<int>(args.size()), args.data(), NULL);
+    formatArgv(static_cast<int>(args.size()), args.data(), lens.data());
 }
 
 /* Format HSET key multiple field value command */
@@ -96,12 +88,9 @@ void RedisCommand::formatHDEL(const std::string& key, const std::vector<std::str
 {
     if (fields.empty()) throw std::invalid_argument("empty values");
 
-    std::vector<const char *> args = {"HDEL", key.c_str()};
-    for (const std::string &f : fields)
-    {
-        args.push_back(f.c_str());
-    }
-    formatArgv(static_cast<int>(args.size()), args.data(), NULL);
+    std::vector<string> args = {"HDEL", key};
+    args.insert(args.end(), fields.begin(), fields.end());
+    format(args);
 }
 
 /* Format EXPIRE key field command */
@@ -124,12 +113,12 @@ void RedisCommand::formatDEL(const std::string& key)
 
 const char *RedisCommand::c_str() const
 {
-    return temp;
+    return m_str.getStr();
 }
 
 size_t RedisCommand::length() const
 {
-    return strlen(temp);
+    return static_cast<size_t>(m_str.getLen());
 }
 
 }

common/rediscommand.h

@@ -7,6 +7,8 @@
 #include <stdexcept>
 #include <map>
 
+#include "redisstring.h"
+
 namespace swss {
 
 typedef std::pair<std::string, std::string> FieldValueTuple;
@@ -69,7 +71,7 @@ class RedisCommand {
     size_t length() const;
 
 private:
-    char *temp;
+    RedisString m_str;
 };
 
 template<typename InputIterator>
@@ -80,15 +82,15 @@ void RedisCommand::formatHSET(const std::string &key,
 
     const char* cmd = "HSET";
 
-    std::vector<const char*> args = { cmd, key.c_str() };
+    std::vector<std::string> args = { cmd, key.c_str() };
 
     for (auto i = start; i != stop; i++)
     {
-        args.push_back(fvField(*i).c_str());
-        args.push_back(fvValue(*i).c_str());
+        args.push_back(fvField(*i));
+        args.push_back(fvValue(*i));
     }
 
-    formatArgv((int)args.size(), args.data(), NULL);
+    format(args);
 }
 
 }

common/redisstring.cpp

@@ -0,0 +1,37 @@
+#include "redisstring.h"
+#include <hiredis/hiredis.h>
+
+namespace swss {
+
+RedisString::RedisString()
+    : m_data(nullptr),
+      m_len(0)
+{
+}
+
+RedisString::~RedisString()
+{
+    reset();
+}
+
+void RedisString::reset(char *str, int len)
+{
+    if (m_data != nullptr)
+    {
+        redisFreeCommand(m_data);
+    }
+    m_data = str;
+    m_len = len;
+}
+
+const char *RedisString::getStr() const
+{
+    return m_data;
+}
+
+int RedisString::getLen() const
+{
+    return m_len;
+}
+
+}

common/redisstring.h

@@ -0,0 +1,23 @@
+#pragma once
+
+namespace swss {
+
+class RedisString {
+public:
+
+    RedisString();
+
+    ~RedisString();
+
+    void reset(char *str = nullptr, int len = 0);
+
+    const char *getStr() const;
+
+    int getLen() const;
+
+private:
+    char *m_data;
+    int m_len;
+};
+
+}