Upgrade bfn swss common to azure swss common master

README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://sonic-jenkins.westus.cloudapp.azure.com/job/common/job/sonic-swss-common-build/badge/icon)](https://sonic-jenkins.westus.cloudapp.azure.com/job/common/job/sonic-swss-common-build/)
+[![Build Status](https://sonic-jenkins.westus2.cloudapp.azure.com/job/common/job/sonic-swss-common-build/badge/icon)](https://sonic-jenkins.westus2.cloudapp.azure.com/job/common/job/sonic-swss-common-build/)
 
 # SONiC - SWitch State Service Common Library - SWSS-COMMON
 
@@ -7,36 +7,18 @@ The SWitch State Service (SWSS) common library provides libraries for database c
 
 ## Getting Started
 
-### Install
+### Build from Source
 
-Before installing, add key and package sources:
+Checkout the source:
 
-    sudo apt-key adv --keyserver apt-mo.trafficmanager.net --recv-keys 417A0893
-    echo 'deb http://apt-mo.trafficmanager.net/repos/sonic/ trusty main' | sudo tee -a /etc/apt/sources.list.d/sonic.list
-    sudo apt-get update
+    git clone --recursive https://github.com/Azure/sonic-swss-common
 
-Install dependencies:
 
-    sudo apt-get install redis-server -t trusty
-    sudo apt-get install libhiredis0.13 -t trusty
+Install build dependencies:
 
-Install building dependencies:
-
-    sudo apt-get install libtool
-    sudo apt-get install autoconf automake
-    sudo apt-get install dh-exec
-
-There are a few different ways you can install SONiC-SWSS.
-
-#### Install from Debian Repo
-
-For your convenience, you can install prepared packages on Debian Jessie:
-
-    sudo apt-get install sonic-swss-common
-
-#### Install from Source
-
-Checkout the source: `git clone https://github.com/Azure/sonic-swss-common.git` and install it yourself.
+    sudo apt-get install make libtool m4 autoconf dh-exec debhelper cmake pkg-config \
+                         libhiredis-dev libnl-3-dev libnl-genl-3-dev libnl-route-3-dev swig3.0 \
+                         libpython2.7-dev
 
 You can compile and install from source using:
 
@@ -48,7 +30,7 @@ You can also build a debian package using:
 
     ./autogen.sh
     ./configure
-    fakeroot debian/rules binary
+    dpkg-buildpackage -us -uc -b
 
 ## Need Help?
 

common/consumer_table_pops.lua

@@ -48,7 +48,7 @@ for i = n, 1, -1 do
            st = st + 2
        end
 
-   elseif op ~= 'get' and op ~= 'getresponse' and op ~= 'notify' then
+   elseif op ~= 'flush' and op ~= 'flushresponse' and op ~= 'get' and op ~= 'getresponse' and op ~= 'notify' then
        local keyname = KEYS[4] .. ':' .. key
        if key == '' then
            keyname = KEYS[4]

common/consumerstatetable.cpp

@@ -11,8 +11,8 @@
 
 namespace swss {
 
-ConsumerStateTable::ConsumerStateTable(DBConnector *db, std::string tableName, int popBatchSize)
-    : ConsumerTableBase(db, tableName, popBatchSize)
+ConsumerStateTable::ConsumerStateTable(DBConnector *db, const std::string &tableName, int popBatchSize, int pri)
+    : ConsumerTableBase(db, tableName, popBatchSize, pri)
     , TableName_KeySet(tableName)
 {
     for (;;)
@@ -30,7 +30,7 @@ ConsumerStateTable::ConsumerStateTable(DBConnector *db, std::string tableName, i
     setQueueLength(r.getReply<long long int>());
 }
 
-void ConsumerStateTable::pops(std::deque<KeyOpFieldsValuesTuple> &vkco, std::string /*prefix*/)
+void ConsumerStateTable::pops(std::deque<KeyOpFieldsValuesTuple> &vkco, const std::string& /*prefix*/)
 {
     static std::string luaScript = loadLuaScript("consumer_state_table_pops.lua");
 

common/consumerstatetable.h

@@ -10,10 +10,10 @@ namespace swss {
 class ConsumerStateTable : public ConsumerTableBase, public TableName_KeySet
 {
 public:
-    ConsumerStateTable(DBConnector *db, std::string tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE);
+    ConsumerStateTable(DBConnector *db, const std::string &tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE, int pri = 0);
 
     /* Get multiple pop elements */
-    void pops(std::deque<KeyOpFieldsValuesTuple> &vkco, std::string prefix = EMPTY_PREFIX);
+    void pops(std::deque<KeyOpFieldsValuesTuple> &vkco, const std::string &prefix = EMPTY_PREFIX);
 };
 
 }

common/consumertable.cpp

@@ -14,8 +14,8 @@ using namespace std;
 
 namespace swss {
 
-ConsumerTable::ConsumerTable(DBConnector *db, string tableName, int popBatchSize)
-    : ConsumerTableBase(db, tableName, popBatchSize)
+ConsumerTable::ConsumerTable(DBConnector *db, const string &tableName, int popBatchSize, int pri)
+    : ConsumerTableBase(db, tableName, popBatchSize, pri)
     , TableName_KeyValueOpQueues(tableName)
 {
     for (;;)
@@ -34,7 +34,7 @@ ConsumerTable::ConsumerTable(DBConnector *db, string tableName, int popBatchSize
     setQueueLength(r.getReply<long long int>());
 }
 
-void ConsumerTable::pops(deque<KeyOpFieldsValuesTuple> &vkco, string prefix)
+void ConsumerTable::pops(deque<KeyOpFieldsValuesTuple> &vkco, const string &prefix)
 {
     static std::string luaScript = loadLuaScript("consumer_table_pops.lua");
 

common/consumertable.h

@@ -13,10 +13,10 @@ namespace swss {
 class ConsumerTable : public ConsumerTableBase, public TableName_KeyValueOpQueues
 {
 public:
-    ConsumerTable(DBConnector *db, std::string tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE);
+    ConsumerTable(DBConnector *db, const std::string &tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE, int pri = 0);
 
     /* Get multiple pop elements */
-    void pops(std::deque<KeyOpFieldsValuesTuple> &vkco, std::string prefix = EMPTY_PREFIX);
+    void pops(std::deque<KeyOpFieldsValuesTuple> &vkco, const std::string &prefix = EMPTY_PREFIX);
 };
 
 }

common/consumertablebase.cpp

@@ -2,23 +2,19 @@
 
 namespace swss {
 
-ConsumerTableBase::ConsumerTableBase(DBConnector *db, std::string tableName, int popBatchSize):
-        TableConsumable(tableName),
+ConsumerTableBase::ConsumerTableBase(DBConnector *db, const std::string &tableName, int popBatchSize, int pri):
+        TableConsumable(db->getDbId(), tableName, pri),
         RedisTransactioner(db),
         POP_BATCH_SIZE(popBatchSize)
 {
 }
 
-ConsumerTableBase::~ConsumerTableBase()
-{
-}
-
-void ConsumerTableBase::pop(KeyOpFieldsValuesTuple &kco, std::string prefix)
+void ConsumerTableBase::pop(KeyOpFieldsValuesTuple &kco, const std::string &prefix)
 {
     pop(kfvKey(kco), kfvOp(kco), kfvFieldsValues(kco), prefix);
 }
 
-void ConsumerTableBase::pop(std::string &key, std::string &op, std::vector<FieldValueTuple> &fvs, std::string prefix)
+void ConsumerTableBase::pop(std::string &key, std::string &op, std::vector<FieldValueTuple> &fvs, const std::string &prefix)
 {
     if (m_buffer.empty())
     {

common/consumertablebase.h

@@ -10,13 +10,13 @@ class ConsumerTableBase: public TableConsumable, public RedisTransactioner
 public:
     const int POP_BATCH_SIZE;
 
-    ConsumerTableBase(DBConnector *db, std::string tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE);
+    ConsumerTableBase(DBConnector *db, const std::string &tableName, int popBatchSize = DEFAULT_POP_BATCH_SIZE, int pri = 0);
 
-    virtual ~ConsumerTableBase();
+    ~ConsumerTableBase() override = default;
 
-    void pop(KeyOpFieldsValuesTuple &kco, std::string prefix = EMPTY_PREFIX);
+    void pop(KeyOpFieldsValuesTuple &kco, const std::string &prefix = EMPTY_PREFIX);
 
-    void pop(std::string &key, std::string &op, std::vector<FieldValueTuple> &fvs, std::string prefix = EMPTY_PREFIX);
+    void pop(std::string &key, std::string &op, std::vector<FieldValueTuple> &fvs, const std::string &prefix = EMPTY_PREFIX);
 
 protected:
 

common/converter.h

@@ -10,7 +10,7 @@
 
 namespace swss {
 
-static inline uint64_t __to_uint64(std::string str, uint64_t min = std::numeric_limits<uint64_t>::min(), uint64_t max = std::numeric_limits<uint64_t>::max())
+static inline uint64_t __to_uint64(const std::string &str, uint64_t min = std::numeric_limits<uint64_t>::min(), uint64_t max = std::numeric_limits<uint64_t>::max())
 {
     size_t idx = 0;
     uint64_t ret = stoul(str, &idx, 0);
@@ -27,7 +27,7 @@ static inline uint64_t __to_uint64(std::string str, uint64_t min = std::numeric_
     return ret;
 }
 
-static inline int64_t __to_int64(std::string str, int64_t min = std::numeric_limits<int64_t>::min(), int64_t max = std::numeric_limits<int64_t>::max())
+static inline int64_t __to_int64(const std::string &str, int64_t min = std::numeric_limits<int64_t>::min(), int64_t max = std::numeric_limits<int64_t>::max())
 {
     size_t idx = 0;
     int64_t ret = stol(str, &idx, 0);
@@ -45,7 +45,7 @@ static inline int64_t __to_int64(std::string str, int64_t min = std::numeric_lim
 }
 
 template <typename T>
-T to_int(std::string str, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max())
+T to_int(const std::string &str, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max())
 {
     static_assert(std::is_signed<T>::value, "Signed integer is expected");
     static_assert(std::numeric_limits<T>::max() <= std::numeric_limits<int64_t>::max(), "Type is too big");
@@ -54,7 +54,7 @@ T to_int(std::string str, T min = std::numeric_limits<T>::min(), T max = std::nu
 }
 
 template <typename T>
-T to_uint(std::string str, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max())
+T to_uint(const std::string &str, T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max())
 {
     static_assert(std::is_unsigned<T>::value, "Unsigned integer is expected");
     static_assert(std::numeric_limits<T>::max() <= std::numeric_limits<uint64_t>::max(), "Type is too big");

common/dbconnector.cpp

@@ -17,7 +17,7 @@ constexpr const char *DBConnector::DEFAULT_UNIXSOCKET;
 void DBConnector::select(DBConnector *db)
 {
     string select("SELECT ");
-    select += to_string(db->getDB());
+    select += to_string(db->getDbId());
 
     RedisReply r(db, select, REDIS_REPLY_STATUS);
     r.checkStatusOK();
@@ -28,9 +28,9 @@ DBConnector::~DBConnector()
     redisFree(m_conn);
 }
 
-DBConnector::DBConnector(int db, string hostname, int port,
+DBConnector::DBConnector(int dbId, const string& hostname, int port,
                          unsigned int timeout) :
-    m_db(db)
+    m_dbId(dbId)
 {
     struct timeval tv = {0, (suseconds_t)timeout * 1000};
 
@@ -46,8 +46,8 @@ DBConnector::DBConnector(int db, string hostname, int port,
     select(this);
 }
 
-DBConnector::DBConnector(int db, string unixPath, unsigned int timeout) :
-    m_db(db)
+DBConnector::DBConnector(int dbId, const string& unixPath, unsigned int timeout) :
+    m_dbId(dbId)
 {
     struct timeval tv = {0, (suseconds_t)timeout * 1000};
 
@@ -68,20 +68,20 @@ redisContext *DBConnector::getContext()
     return m_conn;
 }
 
-int DBConnector::getDB()
+int DBConnector::getDbId()
 {
-    return m_db;
+    return m_dbId;
 }
 
 DBConnector *DBConnector::newConnector(unsigned int timeout)
 {
     if (getContext()->connection_type == REDIS_CONN_TCP)
-        return new DBConnector(getDB(),
+        return new DBConnector(getDbId(),
                                getContext()->tcp.host,
                                getContext()->tcp.port,
                                timeout);
     else
-        return new DBConnector(getDB(),
+        return new DBConnector(getDbId(),
                                getContext()->unix_sock.path,
                                timeout);
 }

common/dbconnector.h

@@ -20,13 +20,13 @@ class DBConnector
      * Timeout - The time in milisecond until exception is been thrown. For
      *           infinite wait, set this value to 0
      */
-    DBConnector(int db, std::string hostname, int port, unsigned int timeout);
-    DBConnector(int db, std::string unixPath, unsigned int timeout);
+    DBConnector(int dbId, const std::string &hostname, int port, unsigned int timeout);
+    DBConnector(int dbId, const std::string &unixPath, unsigned int timeout);
 
     ~DBConnector();
 
     redisContext *getContext();
-    int getDB();
+    int getDbId();
 
     static void select(DBConnector *db);
 
@@ -35,7 +35,7 @@ class DBConnector
 
 private:
     redisContext *m_conn;
-    int m_db;
+    int m_dbId;
 };
 
 }

common/ipaddress.cpp

@@ -13,7 +13,7 @@ IpAddress::IpAddress(uint32_t ip)
 
 IpAddress::IpAddress(const std::string &ipStr)
 {
-    if (ipStr.find(":") != std::string::npos)
+    if (ipStr.find(':') != std::string::npos)
     {
         m_ip.family = AF_INET6;
     }
@@ -37,3 +37,45 @@ std::string IpAddress::to_string() const
 
     return ipStr;
 }
+
+IpAddress::AddrScope IpAddress::getAddrScope() const
+{
+    /* Auxiliary prefixes used to determine the scope of any given address */
+    static const IpAddress ipv4LinkScopeAddress = IpAddress("169.254.0.0");
+    static const IpAddress ipv6LinkScopeAddress = IpAddress("FE80::0");
+    static const IpAddress ipv4HostScopeAddress = IpAddress("127.0.0.1");
+    static const IpAddress ipv6HostScopeAddress = IpAddress("::1");
+
+    if (isV4())
+    {
+        const uint32_t ip1 = htonl(getV4Addr());
+        const uint32_t ip2 = htonl(ipv4LinkScopeAddress.getV4Addr());
+
+        /* IPv4 local-scope mask is 16 bits long -- mask = 0xffff0000 */
+        if ((ip1 & 0xffff0000) == ip2)
+        {
+            return LINK_SCOPE;
+        }
+        else if (*this == ipv4HostScopeAddress)
+        {
+            return HOST_SCOPE;
+        }
+    }
+    else
+    {
+        const uint8_t *ip1 = getV6Addr();
+        const uint8_t *ip2 = ipv6LinkScopeAddress.getV6Addr();
+
+        /* IPv6 local-scope mask is 10 bits long -- mask = 0xffc0::0 */
+        if ((ip1[0] == ip2[0]) && ((ip1[1] & 0xc0) == ip2[1]))
+        {
+            return LINK_SCOPE;
+        }
+        else if (*this == ipv6HostScopeAddress)
+        {
+            return HOST_SCOPE;
+        }
+    }
+
+    return GLOBAL_SCOPE;
+}

common/ipaddress.h

@@ -19,8 +19,8 @@ struct ip_addr_t {
 class IpAddress
 {
 public:
-    IpAddress() {}
-    IpAddress(const ip_addr_t &ip) { m_ip = ip; }
+    IpAddress() = default;
+    IpAddress(const ip_addr_t &ip) : m_ip(ip) {}
     IpAddress(uint32_t ip);
     IpAddress(const std::string &ipStr);
 
@@ -74,6 +74,14 @@ class IpAddress
 
     std::string to_string() const;
 
+    enum AddrScope {
+        GLOBAL_SCOPE,
+        LINK_SCOPE,
+        HOST_SCOPE
+    };
+
+    IpAddress::AddrScope getAddrScope() const;
+
 private:
     struct ip_addr_t m_ip;
 };

common/ipaddresses.cpp

@@ -11,7 +11,7 @@ using namespace swss;
 IpAddresses::IpAddresses(const string &ipsStr)
 {
     auto ips = tokenize(ipsStr, IP_DELIMITER);
-    for (auto ip : ips)
+    for (const auto &ip : ips)
         m_ips.insert(ip);
 }
 
@@ -39,7 +39,7 @@ bool IpAddresses::contains(const IpAddress &ip) const
 
 bool IpAddresses::contains(const IpAddresses &ips) const
 {
-    for (auto ip : ips.getIpAddresses())
+    for (const auto &ip : ips.getIpAddresses())
     {
         if (!contains(ip))
         {