From 79a730f043dde50c804c107c7ee4d4cca77f4e41 Mon Sep 17 00:00:00 2001
From: Ann Pokora <apokora@juniper.net>
Date: Wed, 23 Jun 2021 09:44:20 -0700
Subject: [PATCH 1/2] sonic-swss updates for MPLS

---
 cfgmgr/intfmgr.cpp              |  43 ++
 cfgmgr/intfmgr.h                |   1 +
 orchagent/Makefile.am           |   1 +
 orchagent/bulker.h              |  41 ++
 orchagent/crmorch.cpp           |  74 ++-
 orchagent/crmorch.h             |   2 +
 orchagent/intfsorch.cpp         |  50 ++
 orchagent/intfsorch.h           |   1 +
 orchagent/label.h               |  80 +++
 orchagent/mplsrouteorch.cpp     | 841 ++++++++++++++++++++++++++++++++
 orchagent/neighorch.cpp         | 134 ++++-
 orchagent/neighorch.h           |   3 +-
 orchagent/nexthopkey.h          | 131 ++++-
 orchagent/orchdaemon.cpp        |   8 +-
 orchagent/port.h                |   1 +
 orchagent/routeorch.cpp         | 179 ++++---
 orchagent/routeorch.h           |  46 +-
 orchagent/saihelper.cpp         |   3 +
 tests/mock_tests/Makefile.am    |   1 +
 tests/mock_tests/aclorch_ut.cpp |  10 +-
 tests/test_mpls.py              | 647 ++++++++++++++++++++++++
 21 files changed, 2155 insertions(+), 142 deletions(-)
 create mode 100644 orchagent/label.h
 create mode 100644 orchagent/mplsrouteorch.cpp
 create mode 100644 tests/test_mpls.py

diff --git a/cfgmgr/intfmgr.cpp b/cfgmgr/intfmgr.cpp
index 836f8acf92..8a066ebf38 100644
--- a/cfgmgr/intfmgr.cpp
+++ b/cfgmgr/intfmgr.cpp
@@ -114,6 +114,33 @@ void IntfMgr::setIntfVrf(const string &alias, const string &vrfName)
     }
 }
 
+bool IntfMgr::setIntfMpls(const string &alias, const string& mpls)
+{
+    stringstream cmd;
+    string res;
+
+    if (mpls == "enable")
+    {
+        cmd << "sysctl -w net.mpls.conf." << alias << ".input=1";
+    }
+    else if ((mpls == "disable") || mpls.empty())
+    {
+        cmd << "sysctl -w net.mpls.conf." << alias << ".input=0";
+    }
+    else
+    {
+        SWSS_LOG_ERROR("MPLS state is invalid: \"%s\"", mpls.c_str());
+        return false;
+    }
+    int ret = swss::exec(cmd.str(), res);
+    // Don't return error unless MPLS is explicitly set
+    if (ret && !mpls.empty())
+    {
+        SWSS_LOG_ERROR("Command '%s' failed with rc %d", cmd.str().c_str(), ret);
+    }
+    return true;
+}
+
 void IntfMgr::addLoopbackIntf(const string &alias)
 {
     stringstream cmd;
@@ -446,6 +473,7 @@ bool IntfMgr::doIntfGeneralTask(const vector<string>& keys,
     string nat_zone = "";
     string proxy_arp = "";
     string grat_arp = "";
+    string mpls = "";
 
     for (auto idx : data)
     {
@@ -472,6 +500,10 @@ bool IntfMgr::doIntfGeneralTask(const vector<string>& keys,
         {
             grat_arp = value;
         }
+        else if (field == "mpls")
+        {
+            mpls = value;
+        }
 
         if (field == "nat_zone")
         {
@@ -517,6 +549,17 @@ bool IntfMgr::doIntfGeneralTask(const vector<string>& keys,
                 FieldValueTuple fvTuple("nat_zone", nat_zone);
                 data.push_back(fvTuple);
             }
+            /* Set mpls */
+            if (!setIntfMpls(alias, mpls))
+            {
+                SWSS_LOG_ERROR("Failed to set MPLS to \"%s\" for the \"%s\" interface", mpls.c_str(), alias.c_str());
+                return false;
+            }
+            if (!mpls.empty())
+            {
+                FieldValueTuple fvTuple("mpls", mpls);
+                data.push_back(fvTuple);
+            }
         }
 
         if (!parentAlias.empty())
diff --git a/cfgmgr/intfmgr.h b/cfgmgr/intfmgr.h
index e72a10be96..655fb4deeb 100644
--- a/cfgmgr/intfmgr.h
+++ b/cfgmgr/intfmgr.h
@@ -29,6 +29,7 @@ class IntfMgr : public Orch
     void setIntfIp(const std::string &alias, const std::string &opCmd, const IpPrefix &ipPrefix);
     void setIntfVrf(const std::string &alias, const std::string &vrfName);
     void setIntfMac(const std::string &alias, const std::string &macAddr);
+    bool setIntfMpls(const std::string &alias, const std::string &mpls);
 
     bool doIntfGeneralTask(const std::vector<std::string>& keys, std::vector<FieldValueTuple> data, const std::string& op);
     bool doIntfAddrTask(const std::vector<std::string>& keys, const std::vector<FieldValueTuple>& data, const std::string& op);
diff --git a/orchagent/Makefile.am b/orchagent/Makefile.am
index 05a689f168..05abdfbcec 100644
--- a/orchagent/Makefile.am
+++ b/orchagent/Makefile.am
@@ -33,6 +33,7 @@ orchagent_SOURCES = \
             orch.cpp \
             notifications.cpp \
             routeorch.cpp \
+            mplsrouteorch.cpp \
             neighorch.cpp \
             intfsorch.cpp \
             portsorch.cpp \
diff --git a/orchagent/bulker.h b/orchagent/bulker.h
index cd1812861b..a4a49b105d 100644
--- a/orchagent/bulker.h
+++ b/orchagent/bulker.h
@@ -41,6 +41,13 @@ static inline bool operator==(const sai_route_entry_t& a, const sai_route_entry_
         ;
 }
 
+static inline bool operator==(const sai_inseg_entry_t& a, const sai_inseg_entry_t& b)
+{
+    return a.switch_id == b.switch_id
+        && a.label == b.label
+        ;
+}
+
 static inline std::size_t hash_value(const sai_ip_prefix_t& a)
 {
     size_t seed = 0;
@@ -85,6 +92,18 @@ namespace std
             return seed;
         }
     };
+
+    template <>
+    struct hash<sai_inseg_entry_t>
+    {
+        size_t operator()(const sai_inseg_entry_t& a) const noexcept
+        {
+            size_t seed = 0;
+            boost::hash_combine(seed, a.switch_id);
+            boost::hash_combine(seed, a.label);
+            return seed;
+        }
+    };
 }
 
 // SAI typedef which is not available in SAI 1.5
@@ -151,6 +170,19 @@ struct SaiBulkerTraits<sai_next_hop_group_api_t>
     //using bulk_set_entry_attribute_fn = sai_bulk_object_set_attribute_fn;
 };
 
+template<>
+struct SaiBulkerTraits<sai_mpls_api_t>
+{
+    using entry_t = sai_inseg_entry_t;
+    using api_t = sai_mpls_api_t;
+    using create_entry_fn = sai_create_inseg_entry_fn;
+    using remove_entry_fn = sai_remove_inseg_entry_fn;
+    using set_entry_attribute_fn = sai_set_inseg_entry_attribute_fn;
+    using bulk_create_entry_fn = sai_bulk_create_inseg_entry_fn;
+    using bulk_remove_entry_fn = sai_bulk_remove_inseg_entry_fn;
+    using bulk_set_entry_attribute_fn = sai_bulk_set_inseg_entry_attribute_fn;
+};
+
 template <typename T>
 class EntityBulker
 {
@@ -550,6 +582,15 @@ inline EntityBulker<sai_fdb_api_t>::EntityBulker(sai_fdb_api_t *api, size_t max_
     */
 }
 
+template <>
+inline EntityBulker<sai_mpls_api_t>::EntityBulker(sai_mpls_api_t *api, size_t max_bulk_size) :
+    max_bulk_size(max_bulk_size)
+{
+    create_entries = api->create_inseg_entries;
+    remove_entries = api->remove_inseg_entries;
+    set_entries_attribute = api->set_inseg_entries_attribute;
+}
+
 template <typename T>
 class ObjectBulker
 {
diff --git a/orchagent/crmorch.cpp b/orchagent/crmorch.cpp
index 14b0cab4d1..e0eb24239b 100644
--- a/orchagent/crmorch.cpp
+++ b/orchagent/crmorch.cpp
@@ -40,7 +40,9 @@ const map<CrmResourceType, string> crmResTypeNameMap =
     { CrmResourceType::CRM_FDB_ENTRY, "FDB_ENTRY" },
     { CrmResourceType::CRM_IPMC_ENTRY, "IPMC_ENTRY" },
     { CrmResourceType::CRM_SNAT_ENTRY, "SNAT_ENTRY" },
-    { CrmResourceType::CRM_DNAT_ENTRY, "DNAT_ENTRY" }
+    { CrmResourceType::CRM_DNAT_ENTRY, "DNAT_ENTRY" },
+    { CrmResourceType::CRM_MPLS_INSEG, "MPLS_INSEG" },
+    { CrmResourceType::CRM_MPLS_NEXTHOP, "MPLS_NEXTHOP" },
 };
 
 const map<CrmResourceType, uint32_t> crmResSaiAvailAttrMap =
@@ -60,7 +62,9 @@ const map<CrmResourceType, uint32_t> crmResSaiAvailAttrMap =
     { CrmResourceType::CRM_FDB_ENTRY, SAI_SWITCH_ATTR_AVAILABLE_FDB_ENTRY },
     { CrmResourceType::CRM_IPMC_ENTRY, SAI_SWITCH_ATTR_AVAILABLE_IPMC_ENTRY},
     { CrmResourceType::CRM_SNAT_ENTRY, SAI_SWITCH_ATTR_AVAILABLE_SNAT_ENTRY },
-    { CrmResourceType::CRM_DNAT_ENTRY, SAI_SWITCH_ATTR_AVAILABLE_DNAT_ENTRY }
+    { CrmResourceType::CRM_DNAT_ENTRY, SAI_SWITCH_ATTR_AVAILABLE_DNAT_ENTRY },
+    { CrmResourceType::CRM_MPLS_INSEG, SAI_OBJECT_TYPE_INSEG_ENTRY },
+    { CrmResourceType::CRM_MPLS_NEXTHOP, SAI_OBJECT_TYPE_NEXT_HOP },
 };
 
 const map<string, CrmResourceType> crmThreshTypeResMap =
@@ -80,7 +84,9 @@ const map<string, CrmResourceType> crmThreshTypeResMap =
     { "fdb_entry_threshold_type", CrmResourceType::CRM_FDB_ENTRY },
     { "ipmc_entry_threshold_type", CrmResourceType::CRM_IPMC_ENTRY },
     { "snat_entry_threshold_type", CrmResourceType::CRM_SNAT_ENTRY },
-    { "dnat_entry_threshold_type", CrmResourceType::CRM_DNAT_ENTRY }
+    { "dnat_entry_threshold_type", CrmResourceType::CRM_DNAT_ENTRY },
+    { "mpls_inseg_threshold_type", CrmResourceType::CRM_MPLS_INSEG },
+    { "mpls_nexthop_threshold_type", CrmResourceType::CRM_MPLS_NEXTHOP },
 };
 
 const map<string, CrmResourceType> crmThreshLowResMap =
@@ -100,7 +106,9 @@ const map<string, CrmResourceType> crmThreshLowResMap =
     {"fdb_entry_low_threshold", CrmResourceType::CRM_FDB_ENTRY },
     {"ipmc_entry_low_threshold", CrmResourceType::CRM_IPMC_ENTRY },
     {"snat_entry_low_threshold", CrmResourceType::CRM_SNAT_ENTRY },
-    {"dnat_entry_low_threshold", CrmResourceType::CRM_DNAT_ENTRY }
+    {"dnat_entry_low_threshold", CrmResourceType::CRM_DNAT_ENTRY },
+    {"mpls_inseg_low_threshold", CrmResourceType::CRM_MPLS_INSEG },
+    {"mpls_nexthop_low_threshold", CrmResourceType::CRM_MPLS_NEXTHOP },
 };
 
 const map<string, CrmResourceType> crmThreshHighResMap =
@@ -120,7 +128,9 @@ const map<string, CrmResourceType> crmThreshHighResMap =
     {"fdb_entry_high_threshold", CrmResourceType::CRM_FDB_ENTRY },
     {"ipmc_entry_high_threshold", CrmResourceType::CRM_IPMC_ENTRY },
     {"snat_entry_high_threshold", CrmResourceType::CRM_SNAT_ENTRY },
-    {"dnat_entry_high_threshold", CrmResourceType::CRM_DNAT_ENTRY }
+    {"dnat_entry_high_threshold", CrmResourceType::CRM_DNAT_ENTRY },
+    {"mpls_inseg_high_threshold", CrmResourceType::CRM_MPLS_INSEG },
+    {"mpls_nexthop_high_threshold", CrmResourceType::CRM_MPLS_NEXTHOP },
 };
 
 const map<string, CrmThresholdType> crmThreshTypeMap =
@@ -147,7 +157,9 @@ const map<string, CrmResourceType> crmAvailCntsTableMap =
     { "crm_stats_fdb_entry_available", CrmResourceType::CRM_FDB_ENTRY },
     { "crm_stats_ipmc_entry_available", CrmResourceType::CRM_IPMC_ENTRY },
     { "crm_stats_snat_entry_available", CrmResourceType::CRM_SNAT_ENTRY },
-    { "crm_stats_dnat_entry_available", CrmResourceType::CRM_DNAT_ENTRY }
+    { "crm_stats_dnat_entry_available", CrmResourceType::CRM_DNAT_ENTRY },
+    { "crm_stats_mpls_inseg_available", CrmResourceType::CRM_MPLS_INSEG },
+    { "crm_stats_mpls_nexthop_available", CrmResourceType::CRM_MPLS_NEXTHOP },
 };
 
 const map<string, CrmResourceType> crmUsedCntsTableMap =
@@ -167,7 +179,9 @@ const map<string, CrmResourceType> crmUsedCntsTableMap =
     { "crm_stats_fdb_entry_used", CrmResourceType::CRM_FDB_ENTRY },
     { "crm_stats_ipmc_entry_used", CrmResourceType::CRM_IPMC_ENTRY },
     { "crm_stats_snat_entry_used", CrmResourceType::CRM_SNAT_ENTRY },
-    { "crm_stats_dnat_entry_used", CrmResourceType::CRM_DNAT_ENTRY }
+    { "crm_stats_dnat_entry_used", CrmResourceType::CRM_DNAT_ENTRY },
+    { "crm_stats_mpls_inseg_used", CrmResourceType::CRM_MPLS_INSEG },
+    { "crm_stats_mpls_nexthop_used", CrmResourceType::CRM_MPLS_NEXTHOP },
 };
 
 CrmOrch::CrmOrch(DBConnector *db, string tableName):
@@ -463,10 +477,10 @@ void CrmOrch::getResAvailableCounters()
                 sai_status_t status = sai_switch_api->get_switch_attribute(gSwitchId, 1, &attr);
                 if (status != SAI_STATUS_SUCCESS)
                 {
-                    if((status == SAI_STATUS_NOT_SUPPORTED) ||
-                       (status == SAI_STATUS_NOT_IMPLEMENTED) ||
-                       SAI_STATUS_IS_ATTR_NOT_SUPPORTED(status) ||
-                       SAI_STATUS_IS_ATTR_NOT_IMPLEMENTED(status))
+                    if ((status == SAI_STATUS_NOT_SUPPORTED) ||
+                        (status == SAI_STATUS_NOT_IMPLEMENTED) ||
+                        SAI_STATUS_IS_ATTR_NOT_SUPPORTED(status) ||
+                        SAI_STATUS_IS_ATTR_NOT_IMPLEMENTED(status))
                     {
                         // mark unsupported resources
                         res.second.resStatus = CrmResourceStatus::CRM_RES_NOT_SUPPORTED;
@@ -536,8 +550,44 @@ void CrmOrch::getResAvailableCounters()
                 break;
             }
 
+            case CrmResourceType::CRM_MPLS_INSEG:
+            {
+                sai_object_type_t objType = static_cast<sai_object_type_t>(crmResSaiAvailAttrMap.at(res.first));
+                uint64_t availCount = 0;
+                sai_status_t status = sai_object_type_get_availability(gSwitchId, objType, 0, nullptr, &availCount);
+                if (status != SAI_STATUS_SUCCESS)
+                {
+                    SWSS_LOG_ERROR("Failed to get availability for object_type %u , rv:%d", objType, status);
+                    break;
+                }
+
+                res.second.countersMap[CRM_COUNTERS_TABLE_KEY].availableCounter = static_cast<uint32_t>(availCount);
+
+                break;
+            }
+
+            case CrmResourceType::CRM_MPLS_NEXTHOP:
+            {
+                sai_object_type_t objType = static_cast<sai_object_type_t>(crmResSaiAvailAttrMap.at(res.first));
+                sai_attribute_t attr;
+                uint64_t availCount = 0;
+
+                attr.id = SAI_NEXT_HOP_ATTR_TYPE;
+                attr.value.s32 = SAI_NEXT_HOP_TYPE_MPLS;
+                sai_status_t status = sai_object_type_get_availability(gSwitchId, objType, 1, &attr, &availCount);
+                if (status != SAI_STATUS_SUCCESS)
+                {
+                    SWSS_LOG_ERROR("Failed to get availability for object_type %u , rv:%d", objType, status);
+                    break;
+                }
+
+                res.second.countersMap[CRM_COUNTERS_TABLE_KEY].availableCounter = static_cast<uint32_t>(availCount);
+
+                break;
+            }
+
             default:
-                SWSS_LOG_ERROR("Failed to get CRM resource type %u. Unknown resource type.\n", (uint32_t)res.first);
+                SWSS_LOG_ERROR("Failed to get CRM resource type %u. Unknown resource type.\n", static_cast<uint32_t>(res.first));
                 return;
         }
     }
diff --git a/orchagent/crmorch.h b/orchagent/crmorch.h
index 7c093ffb24..d8b5522d3a 100644
--- a/orchagent/crmorch.h
+++ b/orchagent/crmorch.h
@@ -28,6 +28,8 @@ enum class CrmResourceType
     CRM_IPMC_ENTRY,
     CRM_SNAT_ENTRY,
     CRM_DNAT_ENTRY,
+    CRM_MPLS_INSEG,
+    CRM_MPLS_NEXTHOP,
 };
 
 enum class CrmThresholdType
diff --git a/orchagent/intfsorch.cpp b/orchagent/intfsorch.cpp
index f3fab3cc61..77957ed414 100644
--- a/orchagent/intfsorch.cpp
+++ b/orchagent/intfsorch.cpp
@@ -177,6 +177,31 @@ void IntfsOrch::decreaseRouterIntfsRefCount(const string &alias)
                   alias.c_str(), m_syncdIntfses[alias].ref_count);
 }
 
+bool IntfsOrch::setRouterIntfsMpls(const Port &port)
+{
+    SWSS_LOG_ENTER();
+
+    sai_attribute_t attr;
+    attr.id = SAI_ROUTER_INTERFACE_ATTR_ADMIN_MPLS_STATE;
+    attr.value.booldata = port.m_mpls;
+
+    sai_status_t status =
+        sai_router_intfs_api->set_router_interface_attribute(port.m_rif_id, &attr);
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        SWSS_LOG_ERROR("Failed to set router interface %s MPLS to %s, rv:%d",
+                       port.m_alias.c_str(), (port.m_mpls ? "enable" : "disable"), status);
+        task_process_status handle_status = handleSaiSetStatus(SAI_API_ROUTER_INTERFACE, status);
+        if (handle_status != task_success)
+        {
+            return parseHandleSaiStatusFailure(handle_status);
+        }
+    }
+    SWSS_LOG_NOTICE("Set router interface %s MPLS to %s", port.m_alias.c_str(),
+                    (port.m_mpls ? "enable" : "disable"));
+    return true;
+}
+
 bool IntfsOrch::setRouterIntfsMtu(const Port &port)
 {
     SWSS_LOG_ENTER();
@@ -618,6 +643,7 @@ void IntfsOrch::doTask(Consumer &consumer)
         uint32_t nat_zone_id = 0;
         string proxy_arp = "";
         string inband_type = "";
+        bool mpls = false;
 
         for (auto idx : data)
         {
@@ -643,6 +669,10 @@ void IntfsOrch::doTask(Consumer &consumer)
                     continue;
                 }
             }
+            else if (field == "mpls")
+            {
+                mpls = (value == "enable" ? true : false);
+            }
             else if (field == "nat_zone")
             {
                 try
@@ -834,6 +864,14 @@ void IntfsOrch::doTask(Consumer &consumer)
                         }
                         gPortsOrch->setPort(alias, port);
                     }
+                    /* Set MPLS */
+                    if ((!ip_prefix_in_key) && (port.m_mpls != mpls))
+                    {
+                        port.m_mpls = mpls;
+
+                        setRouterIntfsMpls(port);
+                        gPortsOrch->setPort(alias, port);
+                    }
                 }
             }
 
@@ -1073,6 +1111,17 @@ bool IntfsOrch::addRouterIntfs(sai_object_id_t vrf_id, Port &port)
     attr.value.u32 = port.m_mtu;
     attrs.push_back(attr);
 
+    if (port.m_mpls)
+    {
+        //  Default value of ADMIN_MPLS_STATE is disabled and does not need
+        //  to be explicitly included in RIF Create request.
+        attr.id = SAI_ROUTER_INTERFACE_ATTR_ADMIN_MPLS_STATE;
+        attr.value.booldata = port.m_mpls;
+
+        SWSS_LOG_INFO("Enabling MPLS on interface %s\n", port.m_alias.c_str());
+        attrs.push_back(attr);
+    }
+
     if (gIsNatSupported)
     {
         attr.id = SAI_ROUTER_INTERFACE_ATTR_NAT_ZONE_ID;
@@ -1135,6 +1184,7 @@ bool IntfsOrch::removeRouterIntfs(Port &port)
     port.m_rif_id = 0;
     port.m_vr_id = 0;
     port.m_nat_zone_id = 0;
+    port.m_mpls = false;
     gPortsOrch->setPort(port.m_alias, port);
 
     SWSS_LOG_NOTICE("Remove router interface for port %s", port.m_alias.c_str());
diff --git a/orchagent/intfsorch.h b/orchagent/intfsorch.h
index 11b947ec29..0235ddb7b9 100644
--- a/orchagent/intfsorch.h
+++ b/orchagent/intfsorch.h
@@ -45,6 +45,7 @@ class IntfsOrch : public Orch
     bool setRouterIntfsMac(const Port &port);
     bool setRouterIntfsNatZoneId(Port &port);
     bool setRouterIntfsAdminStatus(const Port &port);
+    bool setRouterIntfsMpls(const Port &port);
 
     std::set<IpPrefix> getSubnetRoutes();
 
diff --git a/orchagent/label.h b/orchagent/label.h
new file mode 100644
index 0000000000..ddf3a3ab32
--- /dev/null
+++ b/orchagent/label.h
@@ -0,0 +1,80 @@
+#ifndef __LABEL__
+#define __LABEL__
+
+#include <stdint.h>
+#include <vector>
+#include <string>
+#include "converter.h"
+#include "tokenize.h"
+
+namespace swss {
+
+typedef uint32_t Label;
+
+#define LABEL_DELIMITER '/'
+#define LABEL_VALUE_MIN 0
+#define LABEL_VALUE_MAX 0xFFFFF
+
+class LabelStack
+{
+public:
+    LabelStack() = default;
+    // A list of Labels separated by '/'
+    LabelStack(const std::string &str)
+    {
+        auto labels = swss::tokenize(str, LABEL_DELIMITER);
+        for (const auto &i : labels)
+            m_labelstack.emplace_back(to_uint<uint32_t>(i, LABEL_VALUE_MIN, LABEL_VALUE_MAX));
+    }
+
+    inline const std::vector<Label> &getLabelStack() const
+    {
+        return m_labelstack;
+    }
+
+    inline size_t getSize() const
+    {
+        return m_labelstack.size();
+    }
+
+    inline bool empty() const
+    {
+        return m_labelstack.empty();
+    }
+
+    inline bool operator<(const LabelStack &o) const
+    {
+        return m_labelstack < o.m_labelstack;
+    }
+
+    inline bool operator==(const LabelStack &o) const
+    {
+        return m_labelstack == o.m_labelstack;
+    }
+
+    inline bool operator!=(const LabelStack &o) const
+    {
+        return !(*this == o);
+    }
+
+    const std::string to_string() const
+    {
+        std::string str;
+        for (auto it = m_labelstack.begin(); it != m_labelstack.end(); ++it)
+        {
+            if (it != m_labelstack.begin())
+            {
+                str += LABEL_DELIMITER;
+            }
+            str += std::to_string(*it);
+        }
+        return str;
+    }
+
+private:
+    std::vector<Label> m_labelstack;
+};
+
+}
+
+#endif /* __LABEL__ */
diff --git a/orchagent/mplsrouteorch.cpp b/orchagent/mplsrouteorch.cpp
new file mode 100644
index 0000000000..321f259179
--- /dev/null
+++ b/orchagent/mplsrouteorch.cpp
@@ -0,0 +1,841 @@
+#include <assert.h>
+#include <inttypes.h>
+#include <algorithm>
+#include "routeorch.h"
+#include "logger.h"
+#include "swssnet.h"
+#include "converter.h"
+#include "crmorch.h"
+#include "directory.h"
+
+extern sai_object_id_t gVirtualRouterId;
+extern sai_object_id_t gSwitchId;
+
+extern CrmOrch *gCrmOrch;
+
+void RouteOrch::doLabelTask(Consumer& consumer)
+{
+    SWSS_LOG_ENTER();
+
+    auto it = consumer.m_toSync.begin();
+    while (it != consumer.m_toSync.end())
+    {
+        // Route bulk results will be stored in a map
+        std::map<
+                std::pair<
+                        std::string,            // Key
+                        std::string             // Op
+                >,
+                LabelRouteBulkContext
+        >                                       toBulk;
+
+        // Add or remove routes with a route bulker
+        while (it != consumer.m_toSync.end())
+        {
+            KeyOpFieldsValuesTuple t = it->second;
+
+            string key = kfvKey(t);
+            string op = kfvOp(t);
+
+            auto rc = toBulk.emplace(std::piecewise_construct,
+                    std::forward_as_tuple(key, op),
+                    std::forward_as_tuple());
+
+            bool inserted = rc.second;
+            auto& ctx = rc.first->second;
+            if (!inserted)
+            {
+                ctx.clear();
+            }
+
+            /* Get notification from application */
+            /* resync application:
+             * When routeorch receives 'resync' message, it marks all current
+             * routes as dirty and waits for 'resync complete' message. For all
+             * newly received routes, if they match current dirty routes, it unmarks
+             * them dirty. After receiving 'resync complete' message, it creates all
+             * newly added routes and removes all dirty routes.
+             */
+            if (key == "resync")
+            {
+                if (op == "SET")
+                {
+                    /* Mark all current routes as dirty (DEL) in consumer.m_toSync map */
+                    SWSS_LOG_NOTICE("Start resync label routes\n");
+                    for (auto j : m_syncdLabelRoutes)
+                    {
+                        string vrf;
+
+                        if (j.first != gVirtualRouterId)
+                        {
+                            vrf = m_vrfOrch->getVRFname(j.first) + ":";
+                        }
+
+                        for (auto i : j.second)
+                        {
+                            vector<FieldValueTuple> v;
+                            key = vrf + to_string(i.first);
+                            auto x = KeyOpFieldsValuesTuple(key, DEL_COMMAND, v);
+                            consumer.addToSync(x);
+                        }
+                    }
+                    m_resync = true;
+                }
+                else
+                {
+                    SWSS_LOG_NOTICE("Complete resync label routes\n");
+                    m_resync = false;
+                }
+
+                it = consumer.m_toSync.erase(it);
+                continue;
+            }
+
+            if (m_resync)
+            {
+                it++;
+                continue;
+            }
+
+            sai_object_id_t& vrf_id = ctx.vrf_id;
+            Label& label = ctx.label;
+
+            if (!key.compare(0, strlen(VRF_PREFIX), VRF_PREFIX))
+            {
+                size_t found = key.find(':');
+                string vrf_name = key.substr(0, found);
+
+                if (!m_vrfOrch->isVRFexists(vrf_name))
+                {
+                    it++;
+                    continue;
+                }
+                vrf_id = m_vrfOrch->getVRFid(vrf_name);
+                label = to_uint<uint32_t>(key.substr(found+1));
+            }
+            else
+            {
+                vrf_id = gVirtualRouterId;
+                label = to_uint<uint32_t>(key);
+            }
+
+            if (op == SET_COMMAND)
+            {
+                string ips;
+                string aliases;
+                string mpls_nhs;
+                uint8_t& pop_count = ctx.pop_count;
+                bool& excp_intfs_flag = ctx.excp_intfs_flag;
+                bool blackhole = false;
+
+                for (auto i : kfvFieldsValues(t))
+                {
+                    if (fvField(i) == "nexthop")
+                        ips = fvValue(i);
+
+                    if (fvField(i) == "ifname")
+                        aliases = fvValue(i);
+
+                    if (fvField(i) == "mpls_nh")
+                        mpls_nhs = fvValue(i);
+
+                    if (fvField(i) == "mpls_pop")
+                        pop_count = to_uint<uint8_t>(fvValue(i));
+
+                    if (fvField(i) == "blackhole")
+                        blackhole = fvValue(i) == "true";
+                }
+                vector<string> ipv = tokenize(ips, ',');
+                vector<string> alsv = tokenize(aliases, ',');
+                vector<string> mpls_nhv = tokenize(mpls_nhs, ',');
+
+                /* Resize the ip vector to match ifname vector
+                 * as tokenize(",", ',') will miss the last empty segment. */
+                if (alsv.size() == 0 && !blackhole)
+                {
+                    SWSS_LOG_WARN("Skip the route %s, for it has an empty ifname field.", key.c_str());
+                    it = consumer.m_toSync.erase(it);
+                    continue;
+                }
+                else if (alsv.size() != ipv.size())
+                {
+                    SWSS_LOG_NOTICE("Route %s: resize ipv to match alsv, %zd -> %zd.", key.c_str(), ipv.size(), alsv.size());
+                    ipv.resize(alsv.size());
+                }
+
+                /* Set the empty ip(s) to zero
+                 * as IpAddress("") will construct a incorrect ip. */
+                for (auto &ip : ipv)
+                {
+                    if (ip.empty())
+                    {
+                        SWSS_LOG_NOTICE("Route %s: set the empty nexthop ip to zero.", key.c_str());
+                        ip = "0.0.0.0";
+                    }
+                }
+
+                for (auto alias : alsv)
+                {
+                    /* skip route to management, docker, loopback
+                     * TODO: for route to loopback interface, the proper
+                     * way is to create loopback interface and then create
+                     * route pointing to it, so that we can traps packets to
+                     * CPU */
+                    if (alias == "eth0" || alias == "docker0" ||
+                        alias == "lo" || !alias.compare(0, strlen(LOOPBACK_PREFIX), LOOPBACK_PREFIX))
+                    {
+                        excp_intfs_flag = true;
+                        break;
+                    }
+                }
+
+                // TODO: cannot trust m_portsOrch->getPortIdByAlias because sometimes alias is empty
+                if (excp_intfs_flag)
+                {
+                    /* If any existing routes are updated to point to the
+                     * above interfaces, remove them from the ASIC. */
+                    if (removeLabelRoute(ctx))
+                        it = consumer.m_toSync.erase(it);
+                    else
+                        it++;
+                    continue;
+                }
+
+                string nhg_str = "";
+                NextHopGroupKey& nhg = ctx.nhg;
+
+                if (blackhole)
+                {
+                    nhg = NextHopGroupKey();
+                }
+                else
+                {
+                    for (uint32_t i = 0; i < ipv.size(); i++)
+                    {
+                        if (i) nhg_str += NHG_DELIMITER;
+                        if (!mpls_nhv.empty() && mpls_nhv[i] != "na")
+                        {
+                            nhg_str += mpls_nhv[i] + LABELSTACK_DELIMITER;
+                        }
+                        nhg_str += ipv[i] + NH_DELIMITER + alsv[i];
+                    }
+
+                    nhg = NextHopGroupKey(nhg_str);
+                }
+
+                if (nhg.getSize() == 1 && nhg.hasIntfNextHop())
+                {
+                    /* blackhole to be done */
+                    if (alsv[0] == "unknown")
+                    {
+                        /* add addBlackholeRoute or addRoute support empty nhg */
+                        it = consumer.m_toSync.erase(it);
+                    }
+                    /* directly connected route to VRF interface which come from kernel */
+                    else if (!alsv[0].compare(0, strlen(VRF_PREFIX), VRF_PREFIX))
+                    {
+                        it = consumer.m_toSync.erase(it);
+                    }
+                    /* subnet route, vrf leaked route, etc */
+                    else
+                    {
+                        if (addLabelRoute(ctx, nhg))
+                            it = consumer.m_toSync.erase(it);
+                        else
+                            it++;
+                    }
+                }
+                else if (m_syncdLabelRoutes.find(vrf_id) == m_syncdLabelRoutes.end() ||
+                         m_syncdLabelRoutes.at(vrf_id).find(label) == m_syncdLabelRoutes.at(vrf_id).end() ||
+                         m_syncdLabelRoutes.at(vrf_id).at(label) != nhg)
+                {
+                    if (addLabelRoute(ctx, nhg))
+                        it = consumer.m_toSync.erase(it);
+                    else
+                        it++;
+                }
+                else
+                    /* Duplicate entry */
+                    it = consumer.m_toSync.erase(it);
+
+                // If already exhaust the nexthop groups, and there are pending removing routes in bulker,
+                // flush the bulker and possibly collect some released nexthop groups
+                if (m_nextHopGroupCount >= m_maxNextHopGroupCount &&
+                    gLabelRouteBulker.removing_entries_count() > 0)
+                {
+                    break;
+                }
+            }
+            else if (op == DEL_COMMAND)
+            {
+                /* Cannot locate the route or remove succeed */
+                if (removeLabelRoute(ctx))
+                    it = consumer.m_toSync.erase(it);
+                else
+                    it++;
+            }
+            else
+            {
+                SWSS_LOG_ERROR("Unknown operation type %s\n", op.c_str());
+                it = consumer.m_toSync.erase(it);
+            }
+        }
+
+        // Flush the route bulker, so routes will be written to syncd and ASIC
+        gLabelRouteBulker.flush();
+
+        // Go through the bulker results
+        auto it_prev = consumer.m_toSync.begin();
+        m_bulkNhgReducedRefCnt.clear();
+        while (it_prev != it)
+        {
+            KeyOpFieldsValuesTuple t = it_prev->second;
+
+            string key = kfvKey(t);
+            string op = kfvOp(t);
+            auto found = toBulk.find(make_pair(key, op));
+            if (found == toBulk.end())
+            {
+                it_prev++;
+                continue;
+            }
+
+            const auto& ctx = found->second;
+            const auto& object_statuses = ctx.object_statuses;
+            if (object_statuses.empty())
+            {
+                it_prev++;
+                continue;
+            }
+
+            const sai_object_id_t& vrf_id = ctx.vrf_id;
+            const Label& label = ctx.label;
+
+            if (op == SET_COMMAND)
+            {
+                const bool& excp_intfs_flag = ctx.excp_intfs_flag;
+
+                if (excp_intfs_flag)
+                {
+                    /* If any existing routes are updated to point to the
+                     * above interfaces, remove them from the ASIC. */
+                    if (removeLabelRoutePost(ctx))
+                        it_prev = consumer.m_toSync.erase(it_prev);
+                    else
+                        it_prev++;
+                    continue;
+                }
+
+                const NextHopGroupKey& nhg = ctx.nhg;
+
+                if (nhg.getSize() == 1 && nhg.hasIntfNextHop())
+                {
+                    if (addLabelRoutePost(ctx, nhg))
+                        it_prev = consumer.m_toSync.erase(it_prev);
+                    else
+                        it_prev++;
+                }
+                else if (m_syncdLabelRoutes.find(vrf_id) == m_syncdLabelRoutes.end() ||
+                         m_syncdLabelRoutes.at(vrf_id).find(label) == m_syncdLabelRoutes.at(vrf_id).end() ||
+                         m_syncdLabelRoutes.at(vrf_id).at(label) != nhg)
+                {
+                    if (addLabelRoutePost(ctx, nhg))
+                        it_prev = consumer.m_toSync.erase(it_prev);
+                    else
+                        it_prev++;
+                }
+            }
+            else if (op == DEL_COMMAND)
+            {
+                /* Cannot locate the route or remove succeed */
+                if (removeLabelRoutePost(ctx))
+                    it_prev = consumer.m_toSync.erase(it_prev);
+                else
+                    it_prev++;
+            }
+        }
+
+        /* Remove next hop group if the reference count decreases to zero */
+        for (auto& it_nhg : m_bulkNhgReducedRefCnt)
+        {
+            if (m_syncdNextHopGroups[it_nhg.first].ref_count == 0)
+            {
+                removeNextHopGroup(it_nhg.first);
+            }
+        }
+    }
+}
+
+void RouteOrch::addTempLabelRoute(LabelRouteBulkContext& ctx, const NextHopGroupKey &nextHops)
+{
+    SWSS_LOG_ENTER();
+
+    Label& label = ctx.label;
+
+    auto next_hop_set = nextHops.getNextHops();
+
+    /* Remove next hops that are not in m_syncdNextHops */
+    for (auto it = next_hop_set.begin(); it != next_hop_set.end();)
+    {
+        if (!m_neighOrch->hasNextHop(*it))
+        {
+            SWSS_LOG_INFO("Failed to get next hop %s for %u",
+                   (*it).to_string().c_str(), label);
+            it = next_hop_set.erase(it);
+        }
+        else
+            it++;
+    }
+
+    /* Return if next_hop_set is empty */
+    if (next_hop_set.empty())
+        return;
+
+    /* Randomly pick an address from the set */
+    auto it = next_hop_set.begin();
+    advance(it, rand() % next_hop_set.size());
+
+    /* Set the route's temporary next hop to be the randomly picked one */
+    NextHopGroupKey tmp_next_hop((*it).to_string());
+    ctx.tmp_next_hop = tmp_next_hop;
+
+    addLabelRoute(ctx, tmp_next_hop);
+}
+
+bool RouteOrch::addLabelRoute(LabelRouteBulkContext& ctx, const NextHopGroupKey &nextHops)
+{
+    SWSS_LOG_ENTER();
+
+    sai_object_id_t& vrf_id = ctx.vrf_id;
+    Label& label = ctx.label;
+
+    /* next_hop_id indicates the next hop id or next hop group id of this route */
+    sai_object_id_t next_hop_id;
+    bool blackhole = false;
+
+    if (m_syncdLabelRoutes.find(vrf_id) == m_syncdLabelRoutes.end())
+    {
+        m_syncdLabelRoutes.emplace(vrf_id, LabelRouteTable());
+        m_vrfOrch->increaseVrfRefCount(vrf_id);
+    }
+
+    auto it_route = m_syncdLabelRoutes.at(vrf_id).find(label);
+
+    if (nextHops.getSize() == 0)
+    {
+        /* The route is pointing to a blackhole */
+        blackhole = true;
+    }
+    /* The route is pointing to a next hop */
+    else if (nextHops.getSize() == 1)
+    {
+        const NextHopKey& nexthop = *nextHops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
+        {
+            next_hop_id = m_intfsOrch->getRouterIntfsId(nexthop.alias);
+            /* rif is not created yet */
+            if (next_hop_id == SAI_NULL_OBJECT_ID)
+            {
+                SWSS_LOG_INFO("Failed to get next hop %s for %u",
+                        nextHops.to_string().c_str(), label);
+                return false;
+            }
+        }
+        else
+        {
+            if (m_neighOrch->hasNextHop(nexthop))
+            {
+                next_hop_id = m_neighOrch->getNextHopId(nexthop);
+            }
+            /* For non-existent MPLS NH, check if IP neighbor NH exists */
+            else if (nexthop.isMplsNextHop() &&
+                     m_neighOrch->hasNextHop(NextHopKey(nexthop.ip_address, nexthop.alias)))
+            {
+                /* since IP neighbor NH exists, neighbor is resolved, add MPLS NH */
+                m_neighOrch->addNextHop(nexthop);
+                next_hop_id = m_neighOrch->getNextHopId(nexthop);
+            }
+            /* IP neighbor is not yet resolved */
+            else
+            {
+                SWSS_LOG_INFO("Failed to get next hop %s for %u",
+                        nextHops.to_string().c_str(), label);
+                return false;
+            }
+        }
+    }
+    /* The route is pointing to a next hop group */
+    else
+    {
+        /* Check if there is already an existing next hop group */
+        if (!hasNextHopGroup(nextHops))
+        {
+            /* Try to create a new next hop group */
+            if (!addNextHopGroup(nextHops))
+            {
+                for (auto it = nextHops.getNextHops().begin(); it != nextHops.getNextHops().end(); ++it)
+                {
+                    const NextHopKey& nextHop = *it;
+                    if (!m_neighOrch->hasNextHop(nextHop))
+                    {
+                        SWSS_LOG_INFO("Failed to get next hop %s in %s, resolving neighbor",
+                                      nextHop.to_string().c_str(), nextHops.to_string().c_str());
+                        m_neighOrch->resolveNeighbor(nextHop);
+                    }
+                }
+
+                /* Failed to create the next hop group and check if a temporary route is needed */
+
+                /* If the current next hop is part of the next hop group to sync,
+                 * then return false and no need to add another temporary route. */
+                if (it_route != m_syncdLabelRoutes.at(vrf_id).end() && it_route->second.getSize() == 1)
+                {
+                    const NextHopKey& nexthop = *it_route->second.getNextHops().begin();
+                    if (nextHops.contains(nexthop))
+                    {
+                        return false;
+                    }
+                }
+
+                /* Add a temporary route when a next hop group cannot be added,
+                 * and there is no temporary route right now or the current temporary
+                 * route is not pointing to a member of the next hop group to sync. */
+                addTempLabelRoute(ctx, nextHops);
+                /* Return false since the original route is not successfully added */
+                return false;
+            }
+        }
+
+        next_hop_id = m_syncdNextHopGroups[nextHops].next_hop_group_id;
+    }
+
+    /* Sync the inseg entry */
+    sai_inseg_entry_t inseg_entry;
+    // route_entry.vr_id = vrf_id; No VRF support for MPLS?
+    inseg_entry.switch_id = gSwitchId;
+    inseg_entry.label = label;
+
+    sai_attribute_t inseg_attr;
+    auto& object_statuses = ctx.object_statuses;
+
+    /* If the label is not in m_syncdLabelRoutes, then we need to create the route
+     * for this prefix with the new next hop (group) id. If the prefix is already
+     * in m_syncdLabelRoutes, then we need to update the route with a new next hop
+     * (group) id. The old next hop (group) is then not used and the reference
+     * count will decrease by 1.
+     */
+    if (it_route == m_syncdLabelRoutes.at(vrf_id).end())
+    {
+        vector<sai_attribute_t> inseg_attrs;
+        if (blackhole)
+        {
+            inseg_attr.id = SAI_INSEG_ENTRY_ATTR_PACKET_ACTION;
+            inseg_attr.value.s32 = SAI_PACKET_ACTION_DROP;
+        }
+        else
+        {
+            inseg_attr.id = SAI_INSEG_ENTRY_ATTR_NEXT_HOP_ID;
+            inseg_attr.value.oid = next_hop_id;
+        }
+        inseg_attrs.push_back(inseg_attr);
+        inseg_attr.id = SAI_INSEG_ENTRY_ATTR_NUM_OF_POP;
+        inseg_attr.value.u32 = ctx.pop_count;
+        inseg_attrs.push_back(inseg_attr);
+
+        /* Default SAI_INSEG_ENTRY_ATTR_PACKET_ACTION is SAI_PACKET_ACTION_FORWARD */
+        object_statuses.emplace_back();
+        sai_status_t status = gLabelRouteBulker.create_entry(&object_statuses.back(), &inseg_entry, (uint32_t)inseg_attrs.size(), inseg_attrs.data());
+        if (status == SAI_STATUS_ITEM_ALREADY_EXISTS)
+        {
+            SWSS_LOG_ERROR("Failed to create label route %u with next hop(s) %s",
+                           label, nextHops.to_string().c_str());
+            return false;
+        }
+    }
+    else
+    {
+        /* Set the packet action to forward when there was no next hop (dropped) */
+        if (it_route->second.getSize() == 0 && !blackhole)
+        {
+            inseg_attr.id = SAI_INSEG_ENTRY_ATTR_PACKET_ACTION;
+            inseg_attr.value.s32 = SAI_PACKET_ACTION_FORWARD;
+
+            object_statuses.emplace_back();
+            gLabelRouteBulker.set_entry_attribute(&object_statuses.back(), &inseg_entry, &inseg_attr);
+        }
+        else if (blackhole)
+        {
+            inseg_attr.id = SAI_ROUTE_ENTRY_ATTR_PACKET_ACTION;
+            inseg_attr.value.s32 = SAI_PACKET_ACTION_DROP;
+
+            object_statuses.emplace_back();
+            gLabelRouteBulker.set_entry_attribute(&object_statuses.back(), &inseg_entry, &inseg_attr);
+        }
+        else
+        {
+            inseg_attr.id = SAI_INSEG_ENTRY_ATTR_NEXT_HOP_ID;
+            inseg_attr.value.oid = next_hop_id;
+
+            /* Set the next hop ID to a new value */
+            object_statuses.emplace_back();
+            gLabelRouteBulker.set_entry_attribute(&object_statuses.back(), &inseg_entry, &inseg_attr);
+        }
+    }
+    return false;
+}
+
+bool RouteOrch::addLabelRoutePost(const LabelRouteBulkContext& ctx, const NextHopGroupKey &nextHops)
+{
+    SWSS_LOG_ENTER();
+
+    const sai_object_id_t& vrf_id = ctx.vrf_id;
+    const Label& label = ctx.label;
+    bool blackhole = false;
+
+    const auto& object_statuses = ctx.object_statuses;
+
+    if (object_statuses.empty())
+    {
+        // Something went wrong before router bulker, will retry
+        return false;
+    }
+
+    /* next_hop_id indicates the next hop id or next hop group id of this route */
+    sai_object_id_t next_hop_id;
+
+    if (nextHops.getSize() == 0)
+    {
+        /* The route is pointing to a blackhole */
+        blackhole = true;
+    }
+    if (nextHops.getSize() == 1)
+    {
+        /* The route is pointing to a next hop */
+        const NextHopKey& nexthop = *nextHops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
+        {
+            next_hop_id = m_intfsOrch->getRouterIntfsId(nexthop.alias);
+            /* rif is not created yet */
+            if (next_hop_id == SAI_NULL_OBJECT_ID)
+            {
+                SWSS_LOG_INFO("Failed to get next hop %s for label %u",
+                              nextHops.to_string().c_str(), label);
+                return false;
+            }
+        }
+        else
+        {
+            if (!m_neighOrch->hasNextHop(nexthop))
+            {
+                SWSS_LOG_INFO("Failed to get next hop %s for label %u",
+                              nextHops.to_string().c_str(), label);
+                return false;
+            }
+        }
+    }
+    /* The route is pointing to a next hop group */
+    else
+    {
+        if (!hasNextHopGroup(nextHops))
+        {
+            // Previous added an temporary route
+            auto& tmp_next_hop = ctx.tmp_next_hop;
+            addLabelRoutePost(ctx, tmp_next_hop);
+            return false;
+        }
+    }
+
+    auto it_status = object_statuses.begin();
+    auto it_route = m_syncdLabelRoutes.at(vrf_id).find(label);
+    if (it_route == m_syncdLabelRoutes.at(vrf_id).end())
+    {
+        if (*it_status++ != SAI_STATUS_SUCCESS)
+        {
+            SWSS_LOG_ERROR("Failed to create label %u with next hop(s) %s",
+                           label, nextHops.to_string().c_str());
+            /* Clean up the newly created next hop group entry */
+            if (nextHops.getSize() > 1)
+            {
+                removeNextHopGroup(nextHops);
+            }
+            return false;
+        }
+
+        gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_MPLS_INSEG);
+
+        /* Increase the ref_count for the next hop (group) entry */
+        increaseNextHopRefCount(nextHops);
+        SWSS_LOG_INFO("Post create label %u with next hop(s) %s",
+                      label, nextHops.to_string().c_str());
+    }
+    else
+    {
+        sai_status_t status;
+
+        /* Set the packet action to forward when there was no next hop (dropped) and not pointing to blackhole */
+        if (it_route->second.getSize() == 0 && !blackhole)
+        {
+            status = *it_status++;
+            if (status != SAI_STATUS_SUCCESS)
+            {
+                SWSS_LOG_ERROR("Failed to set label %u with packet action forward, %d",
+                               label, status);
+                task_process_status handle_status = handleSaiSetStatus(SAI_API_MPLS, status);
+                if (handle_status != task_success)
+                {
+                    return parseHandleSaiStatusFailure(handle_status);
+                }
+            }
+        }
+
+        status = *it_status++;
+        if (status != SAI_STATUS_SUCCESS)
+        {
+            SWSS_LOG_ERROR("Failed to set label %u with next hop(s) %s",
+                           label, nextHops.to_string().c_str());
+            task_process_status handle_status = handleSaiSetStatus(SAI_API_MPLS, status);
+            if (handle_status != task_success)
+            {
+                return parseHandleSaiStatusFailure(handle_status);
+            }
+        }
+
+        /* Increase the ref_count for the next hop (group) entry */
+        increaseNextHopRefCount(nextHops);
+
+        decreaseNextHopRefCount(it_route->second);
+        if (it_route->second.getSize() > 1
+            && m_syncdNextHopGroups[it_route->second].ref_count == 0)
+        {
+            m_bulkNhgReducedRefCnt.emplace(it_route->second, 0);
+        }
+
+        if (blackhole)
+        {
+            /* Set the packet action to drop for blackhole routes */
+            status = *it_status++;
+            if (status != SAI_STATUS_SUCCESS)
+            {
+                SWSS_LOG_ERROR("Failed to set blackhole label %u with packet action drop, %d",
+                                label, status);
+                task_process_status handle_status = handleSaiSetStatus(SAI_API_MPLS, status);
+                if (handle_status != task_success)
+                {
+                    return parseHandleSaiStatusFailure(handle_status);
+                }
+            }
+        }
+
+        SWSS_LOG_INFO("Post set label %u with next hop(s) %s",
+                      label, nextHops.to_string().c_str());
+    }
+
+    m_syncdLabelRoutes[vrf_id][label] = nextHops;
+
+    return true;
+}
+
+bool RouteOrch::removeLabelRoute(LabelRouteBulkContext& ctx)
+{
+    SWSS_LOG_ENTER();
+
+    sai_object_id_t& vrf_id = ctx.vrf_id;
+    Label& label = ctx.label;
+
+    auto it_route_table = m_syncdLabelRoutes.find(vrf_id);
+    if (it_route_table == m_syncdLabelRoutes.end())
+    {
+        SWSS_LOG_INFO("Failed to find route table, vrf_id 0x%" PRIx64 "\n", vrf_id);
+        return true;
+    }
+
+    sai_inseg_entry_t inseg_entry;
+    //inseg_entry.vr_id = vrf_id; No VRF support for MPLS
+    inseg_entry.switch_id = gSwitchId;
+    inseg_entry.label = label;
+
+    auto it_route = it_route_table->second.find(label);
+    //size_t creating = gLabelRouteBulker.creating_entries_count(inseg_entry);
+    if (it_route == it_route_table->second.end())
+    {
+        SWSS_LOG_INFO("Failed to find inseg entry, vrf_id 0x%" PRIx64 ", label %u\n",
+                      vrf_id, label);
+        return true;
+    }
+
+    auto& object_statuses = ctx.object_statuses;
+
+    object_statuses.emplace_back();
+    gLabelRouteBulker.remove_entry(&object_statuses.back(), &inseg_entry);
+
+    return false;
+}
+
+bool RouteOrch::removeLabelRoutePost(const LabelRouteBulkContext& ctx)
+{
+    SWSS_LOG_ENTER();
+
+    const sai_object_id_t& vrf_id = ctx.vrf_id;
+    const Label& label = ctx.label;
+
+    auto& object_statuses = ctx.object_statuses;
+
+    if (object_statuses.empty())
+    {
+        // Something went wrong before router bulker, will retry
+        return false;
+    }
+
+    auto it_route_table = m_syncdLabelRoutes.find(vrf_id);
+    auto it_route = it_route_table->second.find(label);
+    auto it_status = object_statuses.begin();
+
+    sai_status_t status = *it_status++;
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        SWSS_LOG_ERROR("Failed to remove label:%u\n", label);
+        task_process_status handle_status = handleSaiRemoveStatus(SAI_API_MPLS, status);
+        if (handle_status != task_success)
+        {
+            return parseHandleSaiStatusFailure(handle_status);
+        }
+    }
+
+    gCrmOrch->decCrmResUsedCounter(CrmResourceType::CRM_MPLS_INSEG);
+
+    /*
+     * Decrease the reference count only when the route is pointing to a next hop.
+     */
+    decreaseNextHopRefCount(it_route->second);
+    if (it_route->second.getSize() > 1
+        && m_syncdNextHopGroups[it_route->second].ref_count == 0)
+    {
+        m_bulkNhgReducedRefCnt.emplace(it_route->second, 0);
+    }
+    /*
+     * Additionally check if the NH has label and its ref count == 0, then
+     * remove the label next hop.
+     */
+    else if (it_route->second.getSize() == 1)
+    {
+        const NextHopKey& nexthop = *it_route->second.getNextHops().begin();
+        if (nexthop.isMplsNextHop() &&
+            (m_neighOrch->getNextHopRefCount(nexthop) == 0))
+        {
+            m_neighOrch->removeMplsNextHop(nexthop);
+        }
+    }
+
+    SWSS_LOG_INFO("Remove label %u with next hop(s) %s",
+                  label, it_route->second.to_string().c_str());
+
+    it_route_table->second.erase(label);
+
+    if (it_route_table->second.size() == 0)
+    {
+        m_syncdLabelRoutes.erase(vrf_id);
+        m_vrfOrch->decreaseVrfRefCount(vrf_id);
+    }
+
+    return true;
+}
diff --git a/orchagent/neighorch.cpp b/orchagent/neighorch.cpp
index c7c18b3e31..cc63a86d1c 100644
--- a/orchagent/neighorch.cpp
+++ b/orchagent/neighorch.cpp
@@ -169,15 +169,15 @@ bool NeighOrch::hasNextHop(const NextHopKey &nexthop)
     return m_syncdNextHops.find(nexthop) != m_syncdNextHops.end();
 }
 
-bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
+bool NeighOrch::addNextHop(const NextHopKey &nh)
 {
     SWSS_LOG_ENTER();
 
     Port p;
-    if (!gPortsOrch->getPort(alias, p))
+    if (!gPortsOrch->getPort(nh.alias, p))
     {
         SWSS_LOG_ERROR("Neighbor %s seen on port %s which doesn't exist",
-                        ipAddress.to_string().c_str(), alias.c_str());
+                        nh.ip_address.to_string().c_str(), nh.alias.c_str());
         return false;
     }
     if (p.m_type == Port::SUBPORT)
@@ -185,13 +185,13 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
         if (!gPortsOrch->getPort(p.m_parent_port_id, p))
         {
             SWSS_LOG_ERROR("Neighbor %s seen on sub interface %s whose parent port doesn't exist",
-                            ipAddress.to_string().c_str(), alias.c_str());
+                            nh.ip_address.to_string().c_str(), nh.alias.c_str());
             return false;
         }
     }
 
-    NextHopKey nexthop = { ipAddress, alias };
-    if(m_intfsOrch->isRemoteSystemPortIntf(alias))
+    NextHopKey nexthop(nh);
+    if (m_intfsOrch->isRemoteSystemPortIntf(nexthop.alias))
     {
         //For remote system ports kernel nexthops are always on inband. Change the key
         Port inbp;
@@ -200,18 +200,39 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
 
         nexthop.alias = inbp.m_alias;
     }
+
     assert(!hasNextHop(nexthop));
-    sai_object_id_t rif_id = m_intfsOrch->getRouterIntfsId(alias);
+    sai_object_id_t rif_id = m_intfsOrch->getRouterIntfsId(nexthop.alias);
 
     vector<sai_attribute_t> next_hop_attrs;
 
+    vector<Label> label_stack;
     sai_attribute_t next_hop_attr;
-    next_hop_attr.id = SAI_NEXT_HOP_ATTR_TYPE;
-    next_hop_attr.value.s32 = SAI_NEXT_HOP_TYPE_IP;
-    next_hop_attrs.push_back(next_hop_attr);
+    if (nexthop.isMplsNextHop())
+    {
+        next_hop_attr.id = SAI_NEXT_HOP_ATTR_TYPE;
+        next_hop_attr.value.s32 = SAI_NEXT_HOP_TYPE_MPLS;
+        next_hop_attrs.push_back(next_hop_attr);
+
+        next_hop_attr.id = SAI_NEXT_HOP_ATTR_OUTSEG_TYPE;
+        next_hop_attr.value.s32 = nexthop.outseg_type;
+        next_hop_attrs.push_back(next_hop_attr);
+
+        next_hop_attr.id = SAI_NEXT_HOP_ATTR_LABELSTACK;
+        label_stack = nexthop.label_stack.getLabelStack();
+        next_hop_attr.value.u32list.list = label_stack.data();
+        next_hop_attr.value.u32list.count = static_cast<uint32_t>(nexthop.label_stack.getSize());
+        next_hop_attrs.push_back(next_hop_attr);
+    }
+    else
+    {
+        next_hop_attr.id = SAI_NEXT_HOP_ATTR_TYPE;
+        next_hop_attr.value.s32 = SAI_NEXT_HOP_TYPE_IP;
+        next_hop_attrs.push_back(next_hop_attr);
+    }
 
     next_hop_attr.id = SAI_NEXT_HOP_ATTR_IP;
-    copy(next_hop_attr.value.ipaddr, ipAddress);
+    copy(next_hop_attr.value.ipaddr, nexthop.ip_address);
     next_hop_attrs.push_back(next_hop_attr);
 
     next_hop_attr.id = SAI_NEXT_HOP_ATTR_ROUTER_INTERFACE_ID;
@@ -223,7 +244,7 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
     if (status != SAI_STATUS_SUCCESS)
     {
         SWSS_LOG_ERROR("Failed to create next hop %s on %s, rv:%d",
-                       ipAddress.to_string().c_str(), alias.c_str(), status);
+                       nexthop.ip_address.to_string().c_str(), nexthop.alias.c_str(), status);
         task_process_status handle_status = handleSaiCreateStatus(SAI_API_NEXT_HOP, status);
         if (handle_status != task_success)
         {
@@ -232,7 +253,7 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
     }
 
     SWSS_LOG_NOTICE("Created next hop %s on %s",
-                    ipAddress.to_string().c_str(), alias.c_str());
+                    nexthop.ip_address.to_string().c_str(), nexthop.alias.c_str());
     if (m_neighborToResolve.find(nexthop) != m_neighborToResolve.end())
     {
         clearResolvedNeighborEntry(nexthop);
@@ -246,15 +267,22 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
     next_hop_entry.nh_flags = 0;
     m_syncdNextHops[nexthop] = next_hop_entry;
 
-    m_intfsOrch->increaseRouterIntfsRefCount(alias);
+    m_intfsOrch->increaseRouterIntfsRefCount(nexthop.alias);
 
-    if (ipAddress.isV4())
+    if (nexthop.isMplsNextHop())
     {
-        gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_IPV4_NEXTHOP);
+        gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_MPLS_NEXTHOP);
     }
     else
     {
-        gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_IPV6_NEXTHOP);
+        if (nexthop.ip_address.isV4())
+        {
+            gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_IPV4_NEXTHOP);
+        }
+        else
+        {
+            gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_IPV6_NEXTHOP);
+        }
     }
 
     gFgNhgOrch->validNextHopInNextHopGroup(nexthop);
@@ -268,7 +296,7 @@ bool NeighOrch::addNextHop(const IpAddress &ipAddress, const string &alias)
         if (setNextHopFlag(nexthop, NHFLAGS_IFDOWN) == false)
         {
             SWSS_LOG_WARN("Failed to set NHFLAGS_IFDOWN on nexthop %s for interface %s",
-                ipAddress.to_string().c_str(), alias.c_str());
+                nexthop.ip_address.to_string().c_str(), nexthop.alias.c_str());
         }
     }
     return true;
@@ -416,6 +444,74 @@ bool NeighOrch::removeNextHop(const IpAddress &ipAddress, const string &alias)
     return true;
 }
 
+bool NeighOrch::removeMplsNextHop(const NextHopKey& nh)
+{
+    SWSS_LOG_ENTER();
+
+    NextHopKey nexthop(nh);
+    if (m_intfsOrch->isRemoteSystemPortIntf(nexthop.alias))
+    {
+        //For remote system ports kernel nexthops are always on inband. Change the key
+        Port inbp;
+        gPortsOrch->getInbandPort(inbp);
+        assert(inbp.m_alias.length());
+
+        nexthop.alias = inbp.m_alias;
+    }
+
+    assert(hasNextHop(nexthop));
+
+    SWSS_LOG_INFO("Removing next hop %s", nexthop.to_string().c_str());
+
+    gFgNhgOrch->invalidNextHopInNextHopGroup(nexthop);
+
+    if (m_syncdNextHops[nexthop].ref_count > 0)
+    {
+        SWSS_LOG_ERROR("Failed to remove still referenced next hop %s",
+                       nexthop.to_string().c_str());
+        return false;
+    }
+
+    sai_object_id_t next_hop_id = m_syncdNextHops[nexthop].next_hop_id;
+    sai_status_t status = sai_next_hop_api->remove_next_hop(next_hop_id);
+
+    /*
+     * If the next hop removal fails and not because the next hop doesn't
+     * exist, return false.
+     */
+    if (status != SAI_STATUS_SUCCESS)
+    {
+        /* When next hop is not found, we continue to remove neighbor entry. */
+        if (status == SAI_STATUS_ITEM_NOT_FOUND)
+        {
+            SWSS_LOG_ERROR("Failed to locate next hop %s, rv:%d",
+                           nexthop.to_string().c_str(), status);
+        }
+        else
+        {
+            SWSS_LOG_ERROR("Failed to remove next hop %s, rv:%d",
+                           nexthop.to_string().c_str(), status);
+            task_process_status handle_status = handleSaiRemoveStatus(SAI_API_NEXT_HOP, status);
+            if (handle_status != task_success)
+            {
+                return parseHandleSaiStatusFailure(handle_status);
+            }
+        }
+    }
+    /* If we successfully removed the next hop, decrement the ref counters. */
+    else if (status == SAI_STATUS_SUCCESS)
+    {
+        if (nexthop.isMplsNextHop())
+        {
+            gCrmOrch->decCrmResUsedCounter(CrmResourceType::CRM_MPLS_NEXTHOP);
+        }
+    }
+
+    m_syncdNextHops.erase(nexthop);
+    m_intfsOrch->decreaseRouterIntfsRefCount(nexthop.alias);
+    return true;
+}
+
 bool NeighOrch::removeOverlayNextHop(const NextHopKey &nexthop)
 {
     SWSS_LOG_ENTER();
@@ -731,7 +827,7 @@ bool NeighOrch::addNeighbor(const NeighborEntry &neighborEntry, const MacAddress
             gCrmOrch->incCrmResUsedCounter(CrmResourceType::CRM_IPV6_NEIGHBOR);
         }
 
-        if (!addNextHop(ip_address, alias))
+        if (!addNextHop(NextHopKey(ip_address, alias)))
         {
             status = sai_neighbor_api->remove_neighbor_entry(&neighbor_entry);
             if (status != SAI_STATUS_SUCCESS)
diff --git a/orchagent/neighorch.h b/orchagent/neighorch.h
index 8cd68f0361..8a3ec30c53 100644
--- a/orchagent/neighorch.h
+++ b/orchagent/neighorch.h
@@ -48,6 +48,8 @@ class NeighOrch : public Orch, public Subject, public Observer
     ~NeighOrch();
 
     bool hasNextHop(const NextHopKey&);
+    bool addNextHop(const NextHopKey&);
+    bool removeMplsNextHop(const NextHopKey&);
 
     sai_object_id_t getNextHopId(const NextHopKey&);
     sai_object_id_t getLocalNextHopId(const NextHopKey&);
@@ -87,7 +89,6 @@ class NeighOrch : public Orch, public Subject, public Observer
 
     std::set<NextHopKey> m_neighborToResolve;
 
-    bool addNextHop(const IpAddress&, const string&);
     bool removeNextHop(const IpAddress&, const string&);
 
     bool addNeighbor(const NeighborEntry&, const MacAddress&);
diff --git a/orchagent/nexthopkey.h b/orchagent/nexthopkey.h
index 69a94505ae..d61b0d3168 100644
--- a/orchagent/nexthopkey.h
+++ b/orchagent/nexthopkey.h
@@ -3,7 +3,9 @@
 
 #include "ipaddress.h"
 #include "tokenize.h"
+#include "label.h"
 
+#define LABELSTACK_DELIMITER '+'
 #define NH_DELIMITER '@'
 #define NHG_DELIMITER ','
 #define VRF_PREFIX "Vrf"
@@ -13,22 +15,40 @@ struct NextHopKey
 {
     IpAddress           ip_address;     // neighbor IP address
     string              alias;          // incoming interface alias
+    sai_next_hop_type_t nh_type;        // NH type
     uint32_t            vni;            // Encap VNI overlay nexthop
     MacAddress          mac_address;    // Overlay Nexthop MAC.
+    LabelStack          label_stack;    // MPLS label stack
+    sai_outseg_type_t   outseg_type;    // MPLS outseg type
 
-    NextHopKey() = default;
-    NextHopKey(const std::string &ipstr, const std::string &alias) : ip_address(ipstr), alias(alias), vni(0), mac_address() {}
-    NextHopKey(const IpAddress &ip, const std::string &alias) : ip_address(ip), alias(alias), vni(0), mac_address() {}
-    NextHopKey(const std::string &str)
+    NextHopKey() :
+        nh_type(SAI_NEXT_HOP_TYPE_IP),
+        vni(0), mac_address(),
+        outseg_type(SAI_OUTSEG_TYPE_SWAP) {}
+    NextHopKey(const std::string &str, const std::string &alias) :
+        alias(alias), nh_type(SAI_NEXT_HOP_TYPE_IP),
+        vni(0), mac_address(),
+        outseg_type(SAI_OUTSEG_TYPE_SWAP)
+    {
+        std::string ip_str = parseMplsNextHop(str);
+        ip_address = ip_str;
+    }
+    NextHopKey(const IpAddress &ip, const std::string &alias) :
+        ip_address(ip), alias(alias), nh_type(SAI_NEXT_HOP_TYPE_IP),
+        vni(0), mac_address(),
+        outseg_type(SAI_OUTSEG_TYPE_SWAP) {}
+    NextHopKey(const std::string &str) :
+        nh_type(SAI_NEXT_HOP_TYPE_IP),
+        vni(0), mac_address(),
+        outseg_type(SAI_OUTSEG_TYPE_SWAP)
     {
         if (str.find(NHG_DELIMITER) != string::npos)
         {
             std::string err = "Error converting " + str + " to NextHop";
             throw std::invalid_argument(err);
         }
-        auto keys = tokenize(str, NH_DELIMITER);
-        vni = 0;
-        mac_address = MacAddress();
+        std::string ip_str = parseMplsNextHop(str);
+        auto keys = tokenize(ip_str, NH_DELIMITER);
         if (keys.size() == 1)
         {
             ip_address = keys[0];
@@ -49,14 +69,17 @@ struct NextHopKey
             throw std::invalid_argument(err);
         }
     }
-    NextHopKey(const std::string &str, bool overlay_nh)
+    NextHopKey(const std::string &str, bool overlay_nh) :
+        nh_type(SAI_NEXT_HOP_TYPE_IP),
+        outseg_type(SAI_OUTSEG_TYPE_SWAP)
     {
         if (str.find(NHG_DELIMITER) != string::npos)
         {
             std::string err = "Error converting " + str + " to NextHop";
             throw std::invalid_argument(err);
         }
-        auto keys = tokenize(str, NH_DELIMITER);
+        std::string ip_str = parseMplsNextHop(str);
+        auto keys = tokenize(ip_str, NH_DELIMITER);
         if (keys.size() != 4)
         {
             std::string err = "Error converting " + str + " to NextHop";
@@ -70,23 +93,30 @@ struct NextHopKey
 
     const std::string to_string() const
     {
-        return ip_address.to_string() + NH_DELIMITER + alias;
+        std::string str = formatMplsNextHop();
+        str += ip_address.to_string() + NH_DELIMITER + alias;
+        return str;
     }
 
     const std::string to_string(bool overlay_nh) const
     {
-        std::string s_vni = std::to_string(vni);
-        return ip_address.to_string() + NH_DELIMITER + alias + NH_DELIMITER + s_vni + NH_DELIMITER + mac_address.to_string();
+        std::string str = formatMplsNextHop();
+        str += (ip_address.to_string() + NH_DELIMITER + alias + NH_DELIMITER +
+                std::to_string(vni) + NH_DELIMITER + mac_address.to_string());
+        return str;
     }
 
     bool operator<(const NextHopKey &o) const
     {
-        return tie(ip_address, alias, vni, mac_address) < tie(o.ip_address, o.alias, o.vni, o.mac_address);
+        return tie(ip_address, alias, nh_type, label_stack, outseg_type, vni, mac_address) <
+            tie(o.ip_address, o.alias, o.nh_type, o.label_stack, o.outseg_type, o.vni, o.mac_address);
     }
 
     bool operator==(const NextHopKey &o) const
     {
-        return (ip_address == o.ip_address) && (alias == o.alias) && (vni == o.vni) && (mac_address == o.mac_address);
+        return (ip_address == o.ip_address) && (alias == o.alias) && (nh_type == o.nh_type) &&
+            (label_stack == o.label_stack) && (outseg_type == o.outseg_type) &&
+            (vni == o.vni) && (mac_address == o.mac_address);
     }
 
     bool operator!=(const NextHopKey &o) const
@@ -96,7 +126,78 @@ struct NextHopKey
 
     bool isIntfNextHop() const
     {
-        return (ip_address.getV4Addr() == 0);
+        return (ip_address.isZero());
+    }
+
+    bool isMplsNextHop() const
+    {
+        return (nh_type == SAI_NEXT_HOP_TYPE_MPLS);
+    }
+
+    std::string parseMplsNextHop(const std::string& str)
+    {
+        // parseMplsNextHop initializes MPLS-related member data of the NextHopKey
+        //   based on content of the input param str.
+        //   outseg_type, nh_type, and label_stack may be updated.
+        std::string ip_str;
+        auto keys = tokenize(str, LABELSTACK_DELIMITER);
+        if (keys.size() == 1)
+        {
+            // No MPLS info to parse
+            ip_str = str;
+        }
+        else if (keys.size() == 3)
+        {
+            // Expected MPLS format = "<outsegtype>+<labelstack>+<non-mpls-str>"
+            // key[0] = <outsegtype> = "swap" | "push"
+            // key[1] = <labelstack> = "<label0>/<label1>/../<labelN>"
+            // key[2] = <non-mpls-str> = returned to caller and not parsed here
+            // Example = "push+10100/10101+10.0.0.3@Ethernet4"
+            nh_type = SAI_NEXT_HOP_TYPE_MPLS;
+            if (keys[0] == "swap")
+            {
+                outseg_type = SAI_OUTSEG_TYPE_SWAP;
+            }
+            else if (keys[0] == "push")
+            {
+                outseg_type = SAI_OUTSEG_TYPE_PUSH;
+            }
+            else
+            {
+                // Malformed string
+                std::string err = "Error converting " + str + " to MPLS NextHop";
+                throw std::invalid_argument(err);
+            }
+            label_stack = LabelStack(keys[1]);
+            ip_str = keys[2];
+        }
+        else
+        {
+            // Malformed string
+            std::string err = "Error converting " + str + " to MPLS NextHop";
+            throw std::invalid_argument(err);
+        }
+        return ip_str;
+    }
+
+    std::string formatMplsNextHop() const
+    {
+        std::string str;
+        if (nh_type == SAI_NEXT_HOP_TYPE_MPLS)
+        {
+            if (outseg_type == SAI_OUTSEG_TYPE_SWAP)
+            {
+                str += "swap";
+                str += LABELSTACK_DELIMITER;
+            }
+            else if (outseg_type == SAI_OUTSEG_TYPE_PUSH)
+            {
+                str += "push";
+                str += LABELSTACK_DELIMITER;
+            }
+            str += label_stack.to_string() + LABELSTACK_DELIMITER;
+        }
+        return str;
     }
 };
 
diff --git a/orchagent/orchdaemon.cpp b/orchagent/orchdaemon.cpp
index 4c9fc3a4e7..f8f00cd225 100644
--- a/orchagent/orchdaemon.cpp
+++ b/orchagent/orchdaemon.cpp
@@ -152,7 +152,13 @@ bool OrchDaemon::init()
 
     gFgNhgOrch = new FgNhgOrch(m_configDb, m_applDb, m_stateDb, fgnhg_tables, gNeighOrch, gIntfsOrch, vrf_orch);
     gDirectory.set(gFgNhgOrch);
-    gRouteOrch = new RouteOrch(m_applDb, APP_ROUTE_TABLE_NAME, gSwitchOrch, gNeighOrch, gIntfsOrch, vrf_orch, gFgNhgOrch);
+
+    const int routeorch_pri = 5;
+    vector<table_name_with_pri_t> route_tables = {
+        { APP_ROUTE_TABLE_NAME,        routeorch_pri },
+        { APP_LABEL_ROUTE_TABLE_NAME,  routeorch_pri }
+    };
+    gRouteOrch = new RouteOrch(m_applDb, route_tables, gSwitchOrch, gNeighOrch, gIntfsOrch, vrf_orch, gFgNhgOrch);
 
     CoppOrch  *copp_orch  = new CoppOrch(m_applDb, APP_COPP_TABLE_NAME);
     TunnelDecapOrch *tunnel_decap_orch = new TunnelDecapOrch(m_applDb, APP_TUNNEL_DECAP_TABLE_NAME);
diff --git a/orchagent/port.h b/orchagent/port.h
index dc9f9d1334..57c9f6e2d9 100644
--- a/orchagent/port.h
+++ b/orchagent/port.h
@@ -143,6 +143,7 @@ class Port
     std::vector<uint32_t> m_adv_speeds;
     sai_port_interface_type_t m_interface_type;
     std::vector<uint32_t> m_adv_interface_types;
+    bool      m_mpls = false;
 
     /*
      * Following two bit vectors are used to lock
diff --git a/orchagent/routeorch.cpp b/orchagent/routeorch.cpp
index 1789022173..0f688a64d0 100644
--- a/orchagent/routeorch.cpp
+++ b/orchagent/routeorch.cpp
@@ -12,6 +12,7 @@ extern sai_object_id_t gSwitchId;
 
 extern sai_next_hop_group_api_t*    sai_next_hop_group_api;
 extern sai_route_api_t*             sai_route_api;
+extern sai_mpls_api_t*              sai_mpls_api;
 extern sai_switch_api_t*            sai_switch_api;
 
 extern PortsOrch *gPortsOrch;
@@ -24,12 +25,11 @@ extern size_t gMaxBulkSize;
 #define DEFAULT_NUMBER_OF_ECMP_GROUPS   128
 #define DEFAULT_MAX_ECMP_GROUP_SIZE     32
 
-const int routeorch_pri = 5;
-
-RouteOrch::RouteOrch(DBConnector *db, string tableName, SwitchOrch *switchOrch, NeighOrch *neighOrch, IntfsOrch *intfsOrch, VRFOrch *vrfOrch, FgNhgOrch *fgNhgOrch) :
+RouteOrch::RouteOrch(DBConnector *db, vector<table_name_with_pri_t> &tableNames, SwitchOrch *switchOrch, NeighOrch *neighOrch, IntfsOrch *intfsOrch, VRFOrch *vrfOrch, FgNhgOrch *fgNhgOrch) :
         gRouteBulker(sai_route_api, gMaxBulkSize),
+        gLabelRouteBulker(sai_mpls_api, gMaxBulkSize),
         gNextHopGroupMemberBulker(sai_next_hop_group_api, gSwitchId, gMaxBulkSize),
-        Orch(db, tableName, routeorch_pri),
+        Orch(db, tableNames),
         m_switchOrch(switchOrch),
         m_neighOrch(neighOrch),
         m_intfsOrch(intfsOrch),
@@ -405,6 +405,15 @@ void RouteOrch::doTask(Consumer& consumer)
         return;
     }
 
+    string table_name = consumer.getTableName();
+
+    if (table_name == APP_LABEL_ROUTE_TABLE_NAME)
+    {
+        doLabelTask(consumer);
+        return;
+    }
+
+    /* Default handling is for APP_ROUTE_TABLE_NAME */
     auto it = consumer.m_toSync.begin();
     while (it != consumer.m_toSync.end())
     {
@@ -511,6 +520,7 @@ void RouteOrch::doTask(Consumer& consumer)
             {
                 string ips;
                 string aliases;
+                string mpls_nhs;
                 string vni_labels;
                 string remote_macs;
                 bool& excp_intfs_flag = ctx.excp_intfs_flag;
@@ -525,6 +535,9 @@ void RouteOrch::doTask(Consumer& consumer)
                     if (fvField(i) == "ifname")
                         aliases = fvValue(i);
 
+                    if (fvField(i) == "mpls_nh")
+                        mpls_nhs = fvValue(i);
+
                     if (fvField(i) == "vni_label") {
                         vni_labels = fvValue(i);
                         overlay_nh = true;
@@ -537,9 +550,9 @@ void RouteOrch::doTask(Consumer& consumer)
                         blackhole = fvValue(i) == "true";
                 }
 
-                vector<string>& ipv = ctx.ipv;
-                ipv = tokenize(ips, ',');
+                vector<string> ipv = tokenize(ips, ',');
                 vector<string> alsv = tokenize(aliases, ',');
+                vector<string> mpls_nhv = tokenize(mpls_nhs, ',');
                 vector<string> vni_labelv = tokenize(vni_labels, ',');
                 vector<string> rmacv = tokenize(remote_macs, ',');
 
@@ -609,19 +622,18 @@ void RouteOrch::doTask(Consumer& consumer)
                 }
                 else if (overlay_nh == false)
                 {
-                    if (alsv[0] == "tun0" && !(IpAddress(ipv[0]).isZero()))
-                    {
-                        alsv[0] = gIntfsOrch->getRouterIntfsAlias(ipv[0]);
-                    }
-                    nhg_str = ipv[0] + NH_DELIMITER + alsv[0];
-
-                    for (uint32_t i = 1; i < ipv.size(); i++)
+                    for (uint32_t i = 0; i < ipv.size(); i++)
                     {
+                        if (i) nhg_str += NHG_DELIMITER;
                         if (alsv[i] == "tun0" && !(IpAddress(ipv[i]).isZero()))
                         {
                             alsv[i] = gIntfsOrch->getRouterIntfsAlias(ipv[i]);
                         }
-                        nhg_str += NHG_DELIMITER + ipv[i] + NH_DELIMITER + alsv[i];
+                        if (!mpls_nhv.empty() && mpls_nhv[i] != "na")
+                        {
+                            nhg_str += mpls_nhv[i] + LABELSTACK_DELIMITER;
+                        }
+                        nhg_str += ipv[i] + NH_DELIMITER + alsv[i];
                     }
 
                     nhg = NextHopGroupKey(nhg_str);
@@ -629,16 +641,16 @@ void RouteOrch::doTask(Consumer& consumer)
                 }
                 else
                 {
-                    nhg_str = ipv[0] + NH_DELIMITER + "vni" + alsv[0] + NH_DELIMITER + vni_labelv[0] + NH_DELIMITER + rmacv[0];
-                    for (uint32_t i = 1; i < ipv.size(); i++)
+                    for (uint32_t i = 0; i < ipv.size(); i++)
                     {
-                        nhg_str += NHG_DELIMITER + ipv[i] + NH_DELIMITER + "vni" + alsv[i] + NH_DELIMITER + vni_labelv[i] + NH_DELIMITER + rmacv[i];
+                        if (i) nhg_str += NHG_DELIMITER;
+                        nhg_str += ipv[i] + NH_DELIMITER + "vni" + alsv[i] + NH_DELIMITER + vni_labelv[i] + NH_DELIMITER + rmacv[i];
                     }
 
                     nhg = NextHopGroupKey(nhg_str, overlay_nh);
                 }
 
-                if (ipv.size() == 1 && IpAddress(ipv[0]).isZero())
+                if (nhg.getSize() == 1 && nhg.hasIntfNextHop())
                 {
                     if (alsv[0] == "unknown")
                     {
@@ -740,7 +752,6 @@ void RouteOrch::doTask(Consumer& consumer)
             if (op == SET_COMMAND)
             {
                 const bool& excp_intfs_flag = ctx.excp_intfs_flag;
-                const vector<string>& ipv = ctx.ipv;
 
                 if (excp_intfs_flag)
                 {
@@ -755,7 +766,7 @@ void RouteOrch::doTask(Consumer& consumer)
 
                 const NextHopGroupKey& nhg = ctx.nhg;
 
-                if (ipv.size() == 1 && IpAddress(ipv[0]).isZero())
+                if (nhg.getSize() == 1 && nhg.hasIntfNextHop())
                 {
                     if (addRoutePost(ctx, nhg))
                         it_prev = consumer.m_toSync.erase(it_prev);
@@ -887,18 +898,8 @@ void RouteOrch::increaseNextHopRefCount(const NextHopGroupKey &nexthops)
     }
     else if (nexthops.getSize() == 1)
     {
-        NextHopKey nexthop;
-        bool overlay_nh = nexthops.is_overlay_nexthop();
-        if (overlay_nh)
-        {
-            nexthop = NextHopKey (nexthops.to_string(), overlay_nh);
-        }
-        else
-        {
-            nexthop = NextHopKey (nexthops.to_string());
-        }
-
-        if (nexthop.ip_address.isZero())
+        const NextHopKey& nexthop = *nexthops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
             m_intfsOrch->increaseRouterIntfsRefCount(nexthop.alias);
         else
             m_neighOrch->increaseNextHopRefCount(nexthop);
@@ -918,18 +919,8 @@ void RouteOrch::decreaseNextHopRefCount(const NextHopGroupKey &nexthops)
     }
     else if (nexthops.getSize() == 1)
     {
-        NextHopKey nexthop;
-        bool overlay_nh = nexthops.is_overlay_nexthop();
-        if (overlay_nh)
-        {
-            nexthop = NextHopKey (nexthops.to_string(), overlay_nh);
-        }
-        else
-        {
-            nexthop = NextHopKey (nexthops.to_string());
-        }
-
-        if (nexthop.ip_address.isZero())
+        const NextHopKey& nexthop = *nexthops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
             m_intfsOrch->decreaseRouterIntfsRefCount(nexthop.alias);
         else
             m_neighOrch->decreaseNextHopRefCount(nexthop);
@@ -1040,7 +1031,19 @@ bool RouteOrch::addNextHopGroup(const NextHopGroupKey &nexthops)
      * and add the corresponding next_hop_id to next_hop_ids. */
     for (auto it : next_hop_set)
     {
-        if (!m_neighOrch->hasNextHop(it))
+        sai_object_id_t next_hop_id;
+        if (m_neighOrch->hasNextHop(it))
+        {
+            next_hop_id = m_neighOrch->getNextHopId(it);
+        }
+        /* See if there is an IP neighbor NH for MPLS NH*/
+        else if (it.isMplsNextHop() &&
+                 m_neighOrch->hasNextHop(NextHopKey(it.ip_address, it.alias)))
+        {
+            m_neighOrch->addNextHop(it);
+            next_hop_id = m_neighOrch->getNextHopId(it);
+        }
+        else
         {
             SWSS_LOG_INFO("Failed to get next hop %s in %s",
                     it.to_string().c_str(), nexthops.to_string().c_str());
@@ -1053,7 +1056,6 @@ bool RouteOrch::addNextHopGroup(const NextHopGroupKey &nexthops)
             continue;
         }
 
-        sai_object_id_t next_hop_id = m_neighOrch->getNextHopId(it);
         next_hop_ids.push_back(next_hop_id);
         if (nhopgroup_members_set.find(next_hop_id) == nhopgroup_members_set.end())
         {
@@ -1260,6 +1262,12 @@ bool RouteOrch::removeNextHopGroup(const NextHopGroupKey &nexthops)
                 }
             }
         }
+        /* Remove any MPLS-specific NH that was created */
+        else if (it.isMplsNextHop() &&
+                 (m_neighOrch->getNextHopRefCount(it) == 0))
+        {
+            m_neighOrch->removeMplsNextHop(it);
+        }
     }
     m_syncdNextHopGroups.erase(nexthops);
 
@@ -1398,17 +1406,8 @@ bool RouteOrch::addRoute(RouteBulkContext& ctx, const NextHopGroupKey &nextHops)
     else if (nextHops.getSize() == 1)
     {
         /* The route is pointing to a next hop */
-        NextHopKey nexthop;
-        if (overlay_nh)
-        {
-            nexthop = NextHopKey(nextHops.to_string(), overlay_nh);
-        }
-        else
-        {
-            nexthop = NextHopKey(nextHops.to_string());
-        }
-
-        if (nexthop.ip_address.isZero())
+        const NextHopKey& nexthop = *nextHops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
         {
             if(gPortsOrch->isInbandPort(nexthop.alias))
             {
@@ -1434,6 +1433,15 @@ bool RouteOrch::addRoute(RouteBulkContext& ctx, const NextHopGroupKey &nextHops)
             {
                 next_hop_id = m_neighOrch->getNextHopId(nexthop);
             }
+            /* For non-existent MPLS NH, check if IP neighbor NH exists */
+            else if (nexthop.isMplsNextHop() &&
+                     m_neighOrch->hasNextHop(NextHopKey(nexthop.ip_address, nexthop.alias)))
+            {
+                /* since IP neighbor NH exists, neighbor is resolved, add MPLS NH */
+                m_neighOrch->addNextHop(nexthop);
+                next_hop_id = m_neighOrch->getNextHopId(nexthop);
+            }
+            /* IP neighbor is not yet resolved */
             else
             {
                 if(overlay_nh)
@@ -1471,20 +1479,9 @@ bool RouteOrch::addRoute(RouteBulkContext& ctx, const NextHopGroupKey &nextHops)
             /* Try to create a new next hop group */
             if (!addNextHopGroup(nextHops))
             {
-                /* NextHopGroup is in "Ip1|alias1,Ip2|alias2,..." format*/
-                std::vector<std::string> nhops = tokenize(nextHops.to_string(), ',');
-                for(auto it = nhops.begin(); it != nhops.end(); ++it)
+                for(auto it = nextHops.getNextHops().begin(); it != nextHops.getNextHops().end(); ++it)
                 {
-                    NextHopKey nextHop;
-                    if (overlay_nh)
-                    {
-                        nextHop = NextHopKey(*it, overlay_nh);
-                    }
-                    else
-                    {
-                        nextHop = NextHopKey(*it);
-                    }
-
+                    const NextHopKey& nextHop = *it;
                     if(!m_neighOrch->hasNextHop(nextHop))
                     {
                         if(overlay_nh)
@@ -1518,15 +1515,7 @@ bool RouteOrch::addRoute(RouteBulkContext& ctx, const NextHopGroupKey &nextHops)
                  * then return false and no need to add another temporary route. */
                 if (it_route != m_syncdRoutes.at(vrf_id).end() && it_route->second.getSize() == 1)
                 {
-                    NextHopKey nexthop;
-                    auto old_nextHops = it_route->second;
-
-                    if (old_nextHops.is_overlay_nexthop()) {
-                        nexthop = NextHopKey(old_nextHops.to_string(), true);
-                    } else {
-                        nexthop = NextHopKey(it_route->second.to_string());
-                    }
-
+                    const NextHopKey& nexthop = *it_route->second.getNextHops().begin();
                     if (nextHops.contains(nexthop))
                     {
                         return false;
@@ -1656,14 +1645,8 @@ bool RouteOrch::addRoutePost(const RouteBulkContext& ctx, const NextHopGroupKey
     else if (nextHops.getSize() == 1)
     {
         /* The route is pointing to a next hop */
-        NextHopKey nexthop;
-        if(nextHops.is_overlay_nexthop()) {
-            nexthop = NextHopKey(nextHops.to_string(), true);
-        } else {
-            nexthop = NextHopKey(nextHops.to_string());
-        }
-
-        if (nexthop.ip_address.isZero())
+        const NextHopKey& nexthop = *nextHops.getNextHops().begin();
+        if (nexthop.isIntfNextHop())
         {
             next_hop_id = m_intfsOrch->getRouterIntfsId(nexthop.alias);
             /* rif is not created yet */
@@ -1824,7 +1807,9 @@ bool RouteOrch::addRoutePost(const RouteBulkContext& ctx, const NextHopGroupKey
                 && m_syncdNextHopGroups[it_route->second].ref_count == 0)
             {
                 m_bulkNhgReducedRefCnt.emplace(it_route->second, 0);
-            } else if (ol_nextHops.is_overlay_nexthop()){
+            }
+            else if (ol_nextHops.is_overlay_nexthop())
+            {
                 SWSS_LOG_NOTICE("Update overlay Nexthop %s", ol_nextHops.to_string().c_str());
                 m_bulkNhgReducedRefCnt.emplace(ol_nextHops, vrf_id);
             }
@@ -2002,10 +1987,25 @@ bool RouteOrch::removeRoutePost(const RouteBulkContext& ctx)
             && m_syncdNextHopGroups[it_route->second].ref_count == 0)
         {
             m_bulkNhgReducedRefCnt.emplace(it_route->second, 0);
-        } else if (ol_nextHops.is_overlay_nexthop()){
+        }
+        else if (ol_nextHops.is_overlay_nexthop())
+        {
             SWSS_LOG_NOTICE("Remove overlay Nexthop %s", ol_nextHops.to_string().c_str());
             m_bulkNhgReducedRefCnt.emplace(ol_nextHops, vrf_id);
         }
+        /*
+         * Additionally check if the NH has label and its ref count == 0, then
+         * remove the label next hop.
+         */
+        else if (it_route->second.getSize() == 1)
+        {
+            const NextHopKey& nexthop = *it_route->second.getNextHops().begin();
+            if (nexthop.isMplsNextHop() &&
+                (m_neighOrch->getNextHopRefCount(nexthop) == 0))
+            {
+                m_neighOrch->removeMplsNextHop(nexthop);
+            }
+        }
     }
 
     SWSS_LOG_INFO("Remove route %s with next hop(s) %s",
@@ -2107,4 +2107,3 @@ bool RouteOrch::removeOverlayNextHops(sai_object_id_t vrf_id, const NextHopGroup
 
     return true;
 }
-
diff --git a/orchagent/routeorch.h b/orchagent/routeorch.h
index e92856467b..aca68624f6 100644
--- a/orchagent/routeorch.h
+++ b/orchagent/routeorch.h
@@ -48,6 +48,10 @@ typedef std::map<NextHopGroupKey, NextHopGroupEntry> NextHopGroupTable;
 typedef std::map<IpPrefix, NextHopGroupKey> RouteTable;
 /* RouteTables: vrf_id, RouteTable */
 typedef std::map<sai_object_id_t, RouteTable> RouteTables;
+/* LabelRouteTable: destination label, next hop address(es) */
+typedef std::map<Label, NextHopGroupKey> LabelRouteTable;
+/* LabelRouteTables: vrf_id, LabelRouteTable */
+typedef std::map<sai_object_id_t, LabelRouteTable> LabelRouteTables;
 /* Host: vrf_id, IpAddress */
 typedef std::pair<sai_object_id_t, IpAddress> Host;
 /* NextHopObserverTable: Host, next hop observer entry */
@@ -67,7 +71,6 @@ struct RouteBulkContext
     sai_object_id_t                     vrf_id;
     IpPrefix                            ip_prefix;
     bool                                excp_intfs_flag;
-    std::vector<string>                 ipv;
 
     RouteBulkContext()
         : excp_intfs_flag(false)
@@ -83,7 +86,35 @@ struct RouteBulkContext
         object_statuses.clear();
         tmp_next_hop.clear();
         nhg.clear();
-        ipv.clear();
+        excp_intfs_flag = false;
+        vrf_id = SAI_NULL_OBJECT_ID;
+    }
+};
+
+struct LabelRouteBulkContext
+{
+    std::deque<sai_status_t>            object_statuses;    // Bulk statuses
+    NextHopGroupKey                     tmp_next_hop;       // Temporary next hop
+    NextHopGroupKey                     nhg;
+    sai_object_id_t                     vrf_id;
+    Label                               label;
+    bool                                excp_intfs_flag;
+    uint8_t                             pop_count;
+
+    LabelRouteBulkContext()
+        : excp_intfs_flag(false)
+    {
+    }
+
+    // Disable any copy constructors
+    LabelRouteBulkContext(const LabelRouteBulkContext&) = delete;
+    LabelRouteBulkContext(LabelRouteBulkContext&&) = delete;
+
+    void clear()
+    {
+        object_statuses.clear();
+        tmp_next_hop.clear();
+        nhg.clear();
         excp_intfs_flag = false;
         vrf_id = SAI_NULL_OBJECT_ID;
     }
@@ -92,7 +123,7 @@ struct RouteBulkContext
 class RouteOrch : public Orch, public Subject
 {
 public:
-    RouteOrch(DBConnector *db, string tableName, SwitchOrch *switchOrch, NeighOrch *neighOrch, IntfsOrch *intfsOrch, VRFOrch *vrfOrch, FgNhgOrch *fgNhgOrch);
+    RouteOrch(DBConnector *db, vector<table_name_with_pri_t> &tableNames, SwitchOrch *switchOrch, NeighOrch *neighOrch, IntfsOrch *intfsOrch, VRFOrch *vrfOrch, FgNhgOrch *fgNhgOrch);
 
     bool hasNextHopGroup(const NextHopGroupKey&) const;
     sai_object_id_t getNextHopGroupId(const NextHopGroupKey&);
@@ -133,6 +164,7 @@ class RouteOrch : public Orch, public Subject
     bool m_resync;
 
     RouteTables m_syncdRoutes;
+    LabelRouteTables m_syncdLabelRoutes;
     NextHopGroupTable m_syncdNextHopGroups;
 
     std::set<std::pair<NextHopGroupKey, sai_object_id_t>> m_bulkNhgReducedRefCnt;
@@ -141,6 +173,7 @@ class RouteOrch : public Orch, public Subject
     NextHopObserverTable m_nextHopObservers;
 
     EntityBulker<sai_route_api_t>           gRouteBulker;
+    EntityBulker<sai_mpls_api_t>            gLabelRouteBulker;
     ObjectBulker<sai_next_hop_group_api_t>  gNextHopGroupMemberBulker;
 
     void addTempRoute(RouteBulkContext& ctx, const NextHopGroupKey&);
@@ -149,10 +182,17 @@ class RouteOrch : public Orch, public Subject
     bool addRoutePost(const RouteBulkContext& ctx, const NextHopGroupKey &nextHops);
     bool removeRoutePost(const RouteBulkContext& ctx);
 
+    void addTempLabelRoute(LabelRouteBulkContext& ctx, const NextHopGroupKey&);
+    bool addLabelRoute(LabelRouteBulkContext& ctx, const NextHopGroupKey&);
+    bool removeLabelRoute(LabelRouteBulkContext& ctx);
+    bool addLabelRoutePost(const LabelRouteBulkContext& ctx, const NextHopGroupKey &nextHops);
+    bool removeLabelRoutePost(const LabelRouteBulkContext& ctx);
+
     std::string getLinkLocalEui64Addr(void);
     void        addLinkLocalRouteToMe(sai_object_id_t vrf_id, IpPrefix linklocal_prefix);
 
     void doTask(Consumer& consumer);
+    void doLabelTask(Consumer& consumer);
 };
 
 #endif /* SWSS_ROUTEORCH_H */
diff --git a/orchagent/saihelper.cpp b/orchagent/saihelper.cpp
index 0ea5ecef0f..dac7b1e92f 100644
--- a/orchagent/saihelper.cpp
+++ b/orchagent/saihelper.cpp
@@ -45,6 +45,7 @@ sai_neighbor_api_t*         sai_neighbor_api;
 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_mpls_api_t*             sai_mpls_api;
 sai_lag_api_t*              sai_lag_api;
 sai_policer_api_t*          sai_policer_api;
 sai_tunnel_api_t*           sai_tunnel_api;
@@ -167,6 +168,7 @@ void initSaiApi()
     sai_api_query(SAI_API_NEXT_HOP,             (void **)&sai_next_hop_api);
     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_MPLS,                 (void **)&sai_mpls_api);
     sai_api_query(SAI_API_LAG,                  (void **)&sai_lag_api);
     sai_api_query(SAI_API_POLICER,              (void **)&sai_policer_api);
     sai_api_query(SAI_API_TUNNEL,               (void **)&sai_tunnel_api);
@@ -197,6 +199,7 @@ void initSaiApi()
     sai_log_set(SAI_API_NEXT_HOP,               SAI_LOG_LEVEL_NOTICE);
     sai_log_set(SAI_API_NEXT_HOP_GROUP,         SAI_LOG_LEVEL_NOTICE);
     sai_log_set(SAI_API_ROUTE,                  SAI_LOG_LEVEL_NOTICE);
+    sai_log_set(SAI_API_MPLS,                   SAI_LOG_LEVEL_NOTICE);
     sai_log_set(SAI_API_LAG,                    SAI_LOG_LEVEL_NOTICE);
     sai_log_set(SAI_API_POLICER,                SAI_LOG_LEVEL_NOTICE);
     sai_log_set(SAI_API_TUNNEL,                 SAI_LOG_LEVEL_NOTICE);
diff --git a/tests/mock_tests/Makefile.am b/tests/mock_tests/Makefile.am
index 75125acc78..30ab875f5d 100644
--- a/tests/mock_tests/Makefile.am
+++ b/tests/mock_tests/Makefile.am
@@ -37,6 +37,7 @@ tests_SOURCES = aclorch_ut.cpp \
                 $(top_srcdir)/orchagent/orch.cpp \
                 $(top_srcdir)/orchagent/notifications.cpp \
                 $(top_srcdir)/orchagent/routeorch.cpp \
+                $(top_srcdir)/orchagent/mplsrouteorch.cpp \
                 $(top_srcdir)/orchagent/fgnhgorch.cpp \
                 $(top_srcdir)/orchagent/neighorch.cpp \
                 $(top_srcdir)/orchagent/intfsorch.cpp \
diff --git a/tests/mock_tests/aclorch_ut.cpp b/tests/mock_tests/aclorch_ut.cpp
index 00b532d7ce..5d5fe5de64 100644
--- a/tests/mock_tests/aclorch_ut.cpp
+++ b/tests/mock_tests/aclorch_ut.cpp
@@ -20,6 +20,7 @@ extern sai_port_api_t *sai_port_api;
 extern sai_vlan_api_t *sai_vlan_api;
 extern sai_bridge_api_t *sai_bridge_api;
 extern sai_route_api_t *sai_route_api;
+extern sai_mpls_api_t *sai_mpls_api;
 extern sai_next_hop_group_api_t* sai_next_hop_group_api;
 extern string gMySwitchType;
 
@@ -265,6 +266,7 @@ namespace aclorch_test
             sai_api_query(SAI_API_PORT, (void **)&sai_port_api);
             sai_api_query(SAI_API_VLAN, (void **)&sai_vlan_api);
             sai_api_query(SAI_API_ROUTE, (void **)&sai_route_api);
+            sai_api_query(SAI_API_MPLS, (void **)&sai_mpls_api);
             sai_api_query(SAI_API_ACL, (void **)&sai_acl_api);
             sai_api_query(SAI_API_NEXT_HOP_GROUP, (void **)&sai_next_hop_group_api);
 
@@ -353,7 +355,12 @@ namespace aclorch_test
             gFgNhgOrch = new FgNhgOrch(m_config_db.get(), m_app_db.get(), m_state_db.get(), fgnhg_tables, gNeighOrch, gIntfsOrch, gVrfOrch);
 
             ASSERT_EQ(gRouteOrch, nullptr);
-            gRouteOrch = new RouteOrch(m_app_db.get(), APP_ROUTE_TABLE_NAME, gSwitchOrch, gNeighOrch, gIntfsOrch, gVrfOrch, gFgNhgOrch);
+            const int routeorch_pri = 5;
+            vector<table_name_with_pri_t> route_tables = {
+                { APP_ROUTE_TABLE_NAME,        routeorch_pri },
+                { APP_LABEL_ROUTE_TABLE_NAME,  routeorch_pri }
+            };
+            gRouteOrch = new RouteOrch(m_app_db.get(), route_tables, gSwitchOrch, gNeighOrch, gIntfsOrch, gVrfOrch, gFgNhgOrch);
 
             PolicerOrch *policer_orch = new PolicerOrch(m_config_db.get(), "POLICER");
 
@@ -408,6 +415,7 @@ namespace aclorch_test
             sai_vlan_api = nullptr;
             sai_bridge_api = nullptr;
             sai_route_api = nullptr;
+            sai_mpls_api = nullptr;
         }
 
         shared_ptr<MockAclOrch> createAclOrch()
diff --git a/tests/test_mpls.py b/tests/test_mpls.py
new file mode 100644
index 0000000000..f637e5325c
--- /dev/null
+++ b/tests/test_mpls.py
@@ -0,0 +1,647 @@
+import os
+import re
+import time
+import json
+import pytest
+
+from swsscommon import swsscommon
+from dvslib.dvs_common import wait_for_result
+
+class TestMplsBase(object):
+    def mpls_appdb_mode(self):
+        # run in APP_DB mode unless using "fpmsyncd -l net"
+        return True
+
+    def setup_db(self, dvs):
+        self.pdb = dvs.get_app_db()
+        self.adb = dvs.get_asic_db()
+        self.cdb = dvs.get_config_db()
+
+    def set_admin_status(self, interface, status):
+        self.cdb.update_entry("PORT", interface, {"admin_status": status})
+
+    def create_l3_intf(self, interface):
+        self.cdb.create_entry("INTERFACE", interface, {"NULL": "NULL"})
+
+    def remove_l3_intf(self, interface):
+        self.cdb.delete_entry("INTERFACE", interface)
+
+    def create_mpls_intf(self, interface):
+        self.cdb.create_entry("INTERFACE", interface, {"mpls": "enable"})
+
+    def remove_mpls_intf(self, interface):
+        self.cdb.delete_entry("INTERFACE", interface)
+
+    def add_ip_address(self, interface, ip):
+        self.cdb.create_entry("INTERFACE", interface + "|" + ip, {"NULL": "NULL"})
+
+    def remove_ip_address(self, interface, ip):
+        self.cdb.delete_entry("INTERFACE", interface + "|" + ip)
+
+    def create_route_entry(self, key, pairs):
+        tbl = swsscommon.ProducerStateTable(self.pdb.db_connection, "ROUTE_TABLE")
+        fvs = swsscommon.FieldValuePairs(list(pairs.items()))
+        tbl.set(key, fvs)
+
+    def remove_route_entry(self, key):
+        tbl = swsscommon.ProducerStateTable(self.pdb.db_connection, "ROUTE_TABLE")
+        tbl._del(key)
+
+    def check_route_entries(self, present, destinations):
+        def _access_function():
+            route_entries = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY")
+            route_destinations = [json.loads(route_entry)["dest"]
+                                  for route_entry in route_entries]
+            if present:
+                return (all(destination in route_destinations for destination in destinations), None)
+            else:
+                return (all(destination not in route_destinations for destination in destinations), None)
+
+        wait_for_result(_access_function)
+
+    def get_route_nexthop(self, prefix):
+        route_entries = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY")
+        for route_entry in route_entries:
+            if json.loads(route_entry)["dest"] == prefix:
+                return self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY", route_entry).get("SAI_ROUTE_ENTRY_ATTR_NEXT_HOP_ID")
+        return None
+
+    def check_route_nexthop(self, prefix, nhtype, ip, ostype, labels):
+        def _access_function():
+            nh = self.get_route_nexthop(prefix)
+            if not bool(nh): return (False, None)
+            fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP", nh)
+            # NH should be in NH Table
+            if not bool(fvs): return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_TYPE") != nhtype: return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_IP") != ip: return (False, None)
+            if nhtype != "SAI_NEXT_HOP_TYPE_MPLS": return (True, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_OUTSEG_TYPE") != ostype: return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_LABELSTACK") != labels: return (False, None)
+            return (True, None)
+
+        wait_for_result(_access_function)
+
+    def check_route_nexthop_group(self, prefix, count):
+        def _access_function():
+            nhg = self.get_route_nexthop(prefix)
+            if not bool(nhg): return (False, None)
+            fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP", nhg)
+            # NH should be in NHG Table
+            if not bool(fvs): return (False, None)
+            keys = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER")
+            matched_nhgms = []
+            for key in keys:
+                fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER", key)
+                if fvs["SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID"] == nhg:
+                    matched_nhgms.append(key)
+
+            if len(matched_nhgms) != count: return (False, None)
+            return (True, None)
+
+        wait_for_result(_access_function)
+
+    def create_inseg_entry(self, key, pairs):
+        tbl = swsscommon.ProducerStateTable(self.pdb.db_connection, "LABEL_ROUTE_TABLE")
+        fvs = swsscommon.FieldValuePairs(list(pairs.items()))
+        tbl.set(key, fvs)
+
+    def remove_inseg_entry(self, key):
+        tbl = swsscommon.ProducerStateTable(self.pdb.db_connection, "LABEL_ROUTE_TABLE")
+        tbl._del(key)
+
+    def check_inseg_entries(self, present, labels):
+        def _access_function():
+            inseg_entries = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_INSEG_ENTRY")
+            inseg_labels = [json.loads(inseg_entry)["label"]
+                                  for inseg_entry in inseg_entries]
+            if present:
+                return (all(label in inseg_labels for label in labels), None)
+            else:
+                return (all(label not in inseg_labels for label in labels), None)
+
+        wait_for_result(_access_function)
+
+    def get_inseg_nexthop(self, label):
+        inseg_entries = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_INSEG_ENTRY")
+        for inseg_entry in inseg_entries:
+            if json.loads(inseg_entry)["label"] == label:
+                return self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_INSEG_ENTRY", inseg_entry).get("SAI_INSEG_ENTRY_ATTR_NEXT_HOP_ID")
+        return None
+
+    def check_inseg_nexthop(self, label, nhtype, ip, ostype, labels):
+        def _access_function():
+            nh = self.get_inseg_nexthop(label)
+            if not bool(nh): return (False, None)
+            fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP", nh)
+            # NH should be in NH Table
+            if not bool(fvs): return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_TYPE") != nhtype: return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_IP") != ip: return (False, None)
+            if nhtype != "SAI_NEXT_HOP_TYPE_MPLS": return (True, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_OUTSEG_TYPE") != ostype: return (False, None)
+            if fvs.get("SAI_NEXT_HOP_ATTR_LABELSTACK") != labels: return (False, None)
+            return (True, None)
+
+        wait_for_result(_access_function)
+
+    def check_inseg_nexthop_group(self, label, count):
+        def _access_function():
+            nhg = self.get_inseg_nexthop(label)
+            if not bool(nhg): return (False, None)
+            fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP", nhg)
+            # NH should be in NHG Table
+            if not bool(fvs): return (False, None)
+            keys = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER")
+            matched_nhgms = []
+            for key in keys:
+                fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP_MEMBER", key)
+                if fvs["SAI_NEXT_HOP_GROUP_MEMBER_ATTR_NEXT_HOP_GROUP_ID"] == nhg:
+                    matched_nhgms.append(key)
+
+            if len(matched_nhgms) != count: return (False, None)
+            return (True, None)
+
+        wait_for_result(_access_function)
+
+    def check_nexthop(self, present, nhtype, ip, ostype, labels):
+        def _access_function():
+            nhs = self.adb.get_keys("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP")
+            for nh in nhs:
+                fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP", nh)
+                if fvs.get("SAI_NEXT_HOP_ATTR_TYPE") != nhtype: continue
+                if fvs.get("SAI_NEXT_HOP_ATTR_IP") != ip: continue
+                if nhtype == "SAI_NEXT_HOP_TYPE_IP": return (present, None)
+                if nhtype != "SAI_NEXT_HOP_TYPE_MPLS": continue
+                if fvs.get("SAI_NEXT_HOP_ATTR_OUTSEG_TYPE") != ostype: continue
+                if fvs.get("SAI_NEXT_HOP_ATTR_LABELSTACK") == labels: return (present, None)
+            return (not present, None)
+
+        wait_for_result(_access_function)
+
+    def check_nexthop_group(self, present, nhg):
+        def _access_function():
+            fvs = self.adb.get_entry("ASIC_STATE:SAI_OBJECT_TYPE_NEXT_HOP_GROUP", nhg)
+            if bool(fvs): return (present, None)
+            return (not present, None)
+
+        wait_for_result(_access_function)
+
+    def clear_srv_config(self, dvs):
+        dvs.servers[0].runcmd("ip address flush dev eth0")
+        dvs.servers[1].runcmd("ip address flush dev eth0")
+        dvs.servers[2].runcmd("ip address flush dev eth0")
+        dvs.servers[3].runcmd("ip address flush dev eth0")
+
+    def setup_mpls(self, dvs, resolve):
+        if not self.mpls_appdb_mode():
+            dvs.runcmd("modprobe mpls_router")
+            dvs.runcmd("modprobe mpls_iptunnel")
+            dvs.runcmd("sysctl -w net.mpls.platform_labels=1000")
+
+        self.setup_db(dvs)
+
+        self.clear_srv_config(dvs)
+
+        # create mpls interface
+        self.create_mpls_intf("Ethernet0")
+        self.create_mpls_intf("Ethernet4")
+        self.create_mpls_intf("Ethernet8")
+
+        # set ip address
+        self.add_ip_address("Ethernet0", "10.0.0.0/31")
+        self.add_ip_address("Ethernet4", "10.0.0.2/31")
+        self.add_ip_address("Ethernet8", "10.0.0.4/31")
+
+        # bring up interface
+        self.set_admin_status("Ethernet0", "up")
+        self.set_admin_status("Ethernet4", "up")
+        self.set_admin_status("Ethernet8", "up")
+
+        # set ip address and default route
+        dvs.servers[0].runcmd("ip address add 10.0.0.1/31 dev eth0")
+        dvs.servers[0].runcmd("ip route add default via 10.0.0.0")
+
+        dvs.servers[1].runcmd("ip address add 10.0.0.3/31 dev eth0")
+        dvs.servers[1].runcmd("ip route add default via 10.0.0.2")
+
+        dvs.servers[2].runcmd("ip address add 10.0.0.5/31 dev eth0")
+        dvs.servers[2].runcmd("ip route add default via 10.0.0.4")
+
+        # get neighbor and arp entry
+        if resolve:
+            dvs.servers[0].runcmd("ping -c 1 10.0.0.3")
+            dvs.servers[2].runcmd("ping -c 1 10.0.0.3")
+
+    def teardown_mpls(self, dvs):
+        # remove ip address
+        self.remove_ip_address("Ethernet0", "10.0.0.0/31")
+        self.remove_ip_address("Ethernet4", "10.0.0.2/31")
+        self.remove_ip_address("Ethernet8", "10.0.0.4/31")
+
+        # remove mpls interface
+        self.remove_mpls_intf("Ethernet0")
+        self.remove_mpls_intf("Ethernet4")
+        self.remove_mpls_intf("Ethernet8")
+
+        self.set_admin_status("Ethernet0", "down")
+        self.set_admin_status("Ethernet4", "down")
+        self.set_admin_status("Ethernet8", "down")
+
+        # remove ip address and default route
+        dvs.servers[0].runcmd("ip route del default dev eth0")
+        dvs.servers[0].runcmd("ip address del 10.0.0.1/31 dev eth0")
+
+        dvs.servers[1].runcmd("ip route del default dev eth0")
+        dvs.servers[1].runcmd("ip address del 10.0.0.3/31 dev eth0")
+
+        dvs.servers[2].runcmd("ip route del default dev eth0")
+        dvs.servers[2].runcmd("ip address del 10.0.0.5/31 dev eth0")
+
+        if not self.mpls_appdb_mode():
+            dvs.runcmd("rmmod mpls_iptunnel")
+            dvs.runcmd("rmmod mpls_router")
+
+class TestMplsRoute(TestMplsBase):
+    """ Functionality tests for mpls """
+    def test_RouteAddRemoveIpRoutePush(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        prefix = "2.2.2.0/24"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "push+201"}
+            self.create_route_entry(prefix, fieldValues)
+        else:
+            # dvs.runcmd("ip route add 2.2.2.0/24 encap mpls 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"ip route 2.2.2.0/24 10.0.0.1 Ethernet0 label 201\"")
+
+        # check application database
+        self.pdb.wait_for_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(True, [prefix])
+        self.check_route_nexthop(prefix, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_PUSH", "1:201")
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_route_entry(prefix)
+        else:
+            # dvs.runcmd("ip route del 2.2.2.0/24 encap mpls 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"no ip route 2.2.2.0/24 10.0.0.1 Ethernet0 label 201\"")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(False, [prefix])
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_PUSH", "1:201")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRouteSwap(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+201", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            # dvs.runcmd("ip -f mpls route add 200 as 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"mpls lsp 200 10.0.0.1 201\"")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop(label, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            # dvs.runcmd("ip -f mpls route del 200 as 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"no mpls lsp 200 10.0.0.1 201\"")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRouteImplicitNull(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            # dvs.runcmd("ip -f mpls route add 200 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"mpls lsp 200 10.0.0.1 implicit-null\"")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop(label, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            # dvs.runcmd("ip -f mpls route del 200 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"no mpls lsp 200 10.0.0.1 implicit-null\"")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        # IP NHs are created by neighbor resolution and should still be present
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRouteExplicitNull(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+0", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            # dvs.runcmd("ip -f mpls route add 200 as 0 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"mpls lsp 200 10.0.0.1 explicit-null\"")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop(label, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:0")
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            # dvs.runcmd("ip -f mpls route del 200 as 0 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"no mpls lsp 200 10.0.0.1 explicit-null\"")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:0")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveIpRoutePushNHG(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        prefix = "2.2.2.0/24"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push+200,push+201"}
+            self.create_route_entry(prefix, fieldValues)
+        else:
+            dvs.runcmd("ip route add 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop encap mpls 201 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(True, [prefix])
+        self.check_route_nexthop_group(prefix, 2)
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_PUSH", "1:200")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_PUSH", "1:201")
+        nhg = self.get_route_nexthop(prefix)
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_route_entry(prefix)
+        else:
+            dvs.runcmd("ip route del 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop encap mpls 201 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(False, [prefix])
+        self.check_nexthop_group(False, nhg)
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_PUSH", "1:200")
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_PUSH", "1:201")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRouteSwapNHG(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "swap+201,swap+202", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            dvs.runcmd("ip -f mpls route add 200 nexthop as 201 via inet 10.0.0.1 dev Ethernet0 nexthop as 202 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop_group(label, 2)
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_SWAP", "1:202")
+        nhg = self.get_inseg_nexthop(label)
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            dvs.runcmd("ip -f mpls route del 200 nexthop as 201 via inet 10.0.0.1 dev Ethernet0 nexthop as 202 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop_group(False, nhg)
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_SWAP", "1:202")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRoutePopNHG(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            dvs.runcmd("ip -f mpls route add 200 nexthop via inet 10.0.0.1 dev Ethernet0 nexthop via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop_group(label, 2)
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.5", "", "")
+        nhg = self.get_inseg_nexthop(label)
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            dvs.runcmd("ip -f mpls route del 200 nexthop via inet 10.0.0.1 dev Ethernet0 nexthop via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop_group(False, nhg)
+        # IP NHs are created by neighbor resolution and should still be present
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.5", "", "")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveIpRouteMixedNHG(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        prefix = "2.2.2.0/24"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push+200,na"}
+            self.create_route_entry(prefix, fieldValues)
+        else:
+            dvs.runcmd("ip route add 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(True, [prefix])
+        self.check_route_nexthop_group(prefix, 2)
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_PUSH", "1:200")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.5", "", "")
+        nhg = self.get_route_nexthop(prefix)
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_route_entry(prefix)
+        else:
+            dvs.runcmd("ip route del 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("ROUTE_TABLE", prefix)
+
+        # check ASIC route database
+        self.check_route_entries(False, [prefix])
+        self.check_nexthop_group(False, nhg)
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:200")
+        # IP NHs are created by neighbor resolution and should still be present
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.5", "", "")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteAddRemoveMplsRouteMixedNHG(self, dvs, testlog):
+        self.setup_mpls(dvs, True)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "na,swap+201", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            dvs.runcmd("ip -f mpls route add 200 nexthop via inet 10.0.0.1 dev Ethernet0 nexthop as 201 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC route database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop_group(label, 2)
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+        nhg = self.get_inseg_nexthop(label)
+
+        # remove inseg entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            dvs.runcmd("ip -f mpls route del 200 nexthop via inet 10.0.0.1 dev Ethernet0 nexthop as 201 via inet 10.0.0.5 dev Ethernet8")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC route database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop_group(False, nhg)
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.5", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+        # IP NHs are created by neighbor resolution and should still be present
+        self.check_nexthop(True, "SAI_NEXT_HOP_TYPE_IP", "10.0.0.1", "", "")
+
+        self.teardown_mpls(dvs)
+
+    def test_RouteUnresolvedMplsRouteSwap(self, dvs, testlog):
+        self.setup_mpls(dvs, False)
+
+        # add route entry
+        label = "200"
+        if self.mpls_appdb_mode():
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+201", "mpls_pop": "1"}
+            self.create_inseg_entry(label, fieldValues)
+        else:
+            # dvs.runcmd("ip -f mpls route add 200 as 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"mpls lsp 200 10.0.0.1 201\"")
+
+        # check application database
+        self.pdb.wait_for_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database. inseg with unresolved NH should not be present.
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+
+        # now resolve the NH
+        dvs.servers[0].runcmd("ping -c 1 10.0.0.3")
+        dvs.servers[2].runcmd("ping -c 1 10.0.0.3")
+
+        # check ASIC inseg database
+        self.check_inseg_entries(True, [label])
+        self.check_inseg_nexthop(label, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+
+        # remove route entry
+        if self.mpls_appdb_mode():
+            self.remove_inseg_entry(label)
+        else:
+            # dvs.runcmd("ip -f mpls route del 200 as 201 via inet 10.0.0.1 dev Ethernet0")
+            dvs.runcmd("vtysh -c \"configure terminal\" -c \"no mpls lsp 200 10.0.0.1 201\"")
+
+        # check application database
+        self.pdb.wait_for_deleted_entry("LABEL_ROUTE_TABLE", label)
+
+        # check ASIC inseg database
+        self.check_inseg_entries(False, [label])
+        self.check_nexthop(False, "SAI_NEXT_HOP_TYPE_MPLS", "10.0.0.1", "SAI_OUTSEG_TYPE_SWAP", "1:201")
+
+        self.teardown_mpls(dvs)
+
+# Add Dummy always-pass test at end as workaroud
+# for issue when Flaky fail on final test it invokes module tear-down before retrying
+def test_nonflaky_dummy():
+    pass

From 0a5e3360f6574e37c9e7a7251e6d20938214226e Mon Sep 17 00:00:00 2001
From: Ann Pokora <apokora@juniper.net>
Date: Thu, 24 Jun 2021 06:19:42 -0700
Subject: [PATCH 2/2] sonic-swss updates for MPLS

---
 orchagent/label.h       | 51 ++++++++++++++++++++++-----
 orchagent/neighorch.cpp |  2 +-
 orchagent/nexthopkey.h  | 78 +++++++++++------------------------------
 tests/test_mpls.py      | 16 ++++-----
 4 files changed, 71 insertions(+), 76 deletions(-)

diff --git a/orchagent/label.h b/orchagent/label.h
index ddf3a3ab32..ae5452c193 100644
--- a/orchagent/label.h
+++ b/orchagent/label.h
@@ -15,14 +15,36 @@ typedef uint32_t Label;
 #define LABEL_VALUE_MIN 0
 #define LABEL_VALUE_MAX 0xFFFFF
 
-class LabelStack
+struct LabelStack
 {
-public:
-    LabelStack() = default;
+    std::vector<Label> m_labelstack;
+    sai_outseg_type_t  m_outseg_type;
+
+    LabelStack() :
+        m_outseg_type(SAI_OUTSEG_TYPE_SWAP) {}
     // A list of Labels separated by '/'
     LabelStack(const std::string &str)
     {
-        auto labels = swss::tokenize(str, LABEL_DELIMITER);
+        // Expected MPLS format = "<outsegtype><labelstack>+<non-mpls-str>"
+        // <outsegtype> = "swap" | "push"
+        // <labelstack> = "<label0>/<label1>/../<labelN>"
+        // <non-mpls-str> = returned to caller and not parsed here
+        // Example = "push10100/10101+10.0.0.3@Ethernet4"
+        if (str.find("swap") == 0)
+        {
+            m_outseg_type = SAI_OUTSEG_TYPE_SWAP;
+        }
+        else if (str.find("push") == 0)
+        {
+            m_outseg_type = SAI_OUTSEG_TYPE_PUSH;
+        }
+        else
+        {
+            // Malformed string
+            std::string err = "Error converting " + str + " to MPLS NextHop";
+            throw std::invalid_argument(err);
+        }
+        auto labels = swss::tokenize(str.substr(4), LABEL_DELIMITER);
         for (const auto &i : labels)
             m_labelstack.emplace_back(to_uint<uint32_t>(i, LABEL_VALUE_MIN, LABEL_VALUE_MAX));
     }
@@ -44,12 +66,14 @@ class LabelStack
 
     inline bool operator<(const LabelStack &o) const
     {
-        return m_labelstack < o.m_labelstack;
+        return tie(m_labelstack, m_outseg_type) <
+            tie(o.m_labelstack, o.m_outseg_type);
     }
 
     inline bool operator==(const LabelStack &o) const
     {
-        return m_labelstack == o.m_labelstack;
+        return (m_labelstack == o.m_labelstack) &&
+            (m_outseg_type == o.m_outseg_type);
     }
 
     inline bool operator!=(const LabelStack &o) const
@@ -60,6 +84,18 @@ class LabelStack
     const std::string to_string() const
     {
         std::string str;
+        if (m_labelstack.empty())
+        {
+            return str;
+        }
+        if (m_outseg_type == SAI_OUTSEG_TYPE_SWAP)
+        {
+            str += "swap";
+        }
+        else if (m_outseg_type == SAI_OUTSEG_TYPE_PUSH)
+        {
+            str += "push";
+        }
         for (auto it = m_labelstack.begin(); it != m_labelstack.end(); ++it)
         {
             if (it != m_labelstack.begin())
@@ -70,9 +106,6 @@ class LabelStack
         }
         return str;
     }
-
-private:
-    std::vector<Label> m_labelstack;
 };
 
 }
diff --git a/orchagent/neighorch.cpp b/orchagent/neighorch.cpp
index cc63a86d1c..bb06208471 100644
--- a/orchagent/neighorch.cpp
+++ b/orchagent/neighorch.cpp
@@ -215,7 +215,7 @@ bool NeighOrch::addNextHop(const NextHopKey &nh)
         next_hop_attrs.push_back(next_hop_attr);
 
         next_hop_attr.id = SAI_NEXT_HOP_ATTR_OUTSEG_TYPE;
-        next_hop_attr.value.s32 = nexthop.outseg_type;
+        next_hop_attr.value.s32 = nexthop.label_stack.m_outseg_type;
         next_hop_attrs.push_back(next_hop_attr);
 
         next_hop_attr.id = SAI_NEXT_HOP_ATTR_LABELSTACK;
diff --git a/orchagent/nexthopkey.h b/orchagent/nexthopkey.h
index d61b0d3168..25461ce08b 100644
--- a/orchagent/nexthopkey.h
+++ b/orchagent/nexthopkey.h
@@ -15,32 +15,21 @@ struct NextHopKey
 {
     IpAddress           ip_address;     // neighbor IP address
     string              alias;          // incoming interface alias
-    sai_next_hop_type_t nh_type;        // NH type
     uint32_t            vni;            // Encap VNI overlay nexthop
     MacAddress          mac_address;    // Overlay Nexthop MAC.
     LabelStack          label_stack;    // MPLS label stack
-    sai_outseg_type_t   outseg_type;    // MPLS outseg type
 
-    NextHopKey() :
-        nh_type(SAI_NEXT_HOP_TYPE_IP),
-        vni(0), mac_address(),
-        outseg_type(SAI_OUTSEG_TYPE_SWAP) {}
+    NextHopKey() = default;
     NextHopKey(const std::string &str, const std::string &alias) :
-        alias(alias), nh_type(SAI_NEXT_HOP_TYPE_IP),
-        vni(0), mac_address(),
-        outseg_type(SAI_OUTSEG_TYPE_SWAP)
+        alias(alias), vni(0), mac_address()
     {
         std::string ip_str = parseMplsNextHop(str);
         ip_address = ip_str;
     }
     NextHopKey(const IpAddress &ip, const std::string &alias) :
-        ip_address(ip), alias(alias), nh_type(SAI_NEXT_HOP_TYPE_IP),
-        vni(0), mac_address(),
-        outseg_type(SAI_OUTSEG_TYPE_SWAP) {}
+        ip_address(ip), alias(alias), vni(0), mac_address() {}
     NextHopKey(const std::string &str) :
-        nh_type(SAI_NEXT_HOP_TYPE_IP),
-        vni(0), mac_address(),
-        outseg_type(SAI_OUTSEG_TYPE_SWAP)
+        vni(0), mac_address()
     {
         if (str.find(NHG_DELIMITER) != string::npos)
         {
@@ -69,9 +58,7 @@ struct NextHopKey
             throw std::invalid_argument(err);
         }
     }
-    NextHopKey(const std::string &str, bool overlay_nh) :
-        nh_type(SAI_NEXT_HOP_TYPE_IP),
-        outseg_type(SAI_OUTSEG_TYPE_SWAP)
+    NextHopKey(const std::string &str, bool overlay_nh)
     {
         if (str.find(NHG_DELIMITER) != string::npos)
         {
@@ -108,14 +95,14 @@ struct NextHopKey
 
     bool operator<(const NextHopKey &o) const
     {
-        return tie(ip_address, alias, nh_type, label_stack, outseg_type, vni, mac_address) <
-            tie(o.ip_address, o.alias, o.nh_type, o.label_stack, o.outseg_type, o.vni, o.mac_address);
+        return tie(ip_address, alias, label_stack, vni, mac_address) <
+            tie(o.ip_address, o.alias, o.label_stack, o.vni, o.mac_address);
     }
 
     bool operator==(const NextHopKey &o) const
     {
-        return (ip_address == o.ip_address) && (alias == o.alias) && (nh_type == o.nh_type) &&
-            (label_stack == o.label_stack) && (outseg_type == o.outseg_type) &&
+        return (ip_address == o.ip_address) && (alias == o.alias) &&
+            (label_stack == o.label_stack) &&
             (vni == o.vni) && (mac_address == o.mac_address);
     }
 
@@ -131,14 +118,14 @@ struct NextHopKey
 
     bool isMplsNextHop() const
     {
-        return (nh_type == SAI_NEXT_HOP_TYPE_MPLS);
+        return (!label_stack.empty());
     }
 
     std::string parseMplsNextHop(const std::string& str)
     {
         // parseMplsNextHop initializes MPLS-related member data of the NextHopKey
         //   based on content of the input param str.
-        //   outseg_type, nh_type, and label_stack may be updated.
+        //   label_stack may be updated.
         std::string ip_str;
         auto keys = tokenize(str, LABELSTACK_DELIMITER);
         if (keys.size() == 1)
@@ -146,30 +133,15 @@ struct NextHopKey
             // No MPLS info to parse
             ip_str = str;
         }
-        else if (keys.size() == 3)
+        else if (keys.size() == 2)
         {
-            // Expected MPLS format = "<outsegtype>+<labelstack>+<non-mpls-str>"
+            // Expected MPLS format = "<outsegtype><labelstack>+<non-mpls-str>"
             // key[0] = <outsegtype> = "swap" | "push"
-            // key[1] = <labelstack> = "<label0>/<label1>/../<labelN>"
-            // key[2] = <non-mpls-str> = returned to caller and not parsed here
-            // Example = "push+10100/10101+10.0.0.3@Ethernet4"
-            nh_type = SAI_NEXT_HOP_TYPE_MPLS;
-            if (keys[0] == "swap")
-            {
-                outseg_type = SAI_OUTSEG_TYPE_SWAP;
-            }
-            else if (keys[0] == "push")
-            {
-                outseg_type = SAI_OUTSEG_TYPE_PUSH;
-            }
-            else
-            {
-                // Malformed string
-                std::string err = "Error converting " + str + " to MPLS NextHop";
-                throw std::invalid_argument(err);
-            }
-            label_stack = LabelStack(keys[1]);
-            ip_str = keys[2];
+            // key[0] = <labelstack> = "<label0>/<label1>/../<labelN>"
+            // key[1] = <non-mpls-str> = returned to caller and not parsed here
+            // Example = "push10100/10101+10.0.0.3@Ethernet4"
+            label_stack = LabelStack(keys[0]);
+            ip_str = keys[1];
         }
         else
         {
@@ -183,19 +155,9 @@ struct NextHopKey
     std::string formatMplsNextHop() const
     {
         std::string str;
-        if (nh_type == SAI_NEXT_HOP_TYPE_MPLS)
+        if (isMplsNextHop())
         {
-            if (outseg_type == SAI_OUTSEG_TYPE_SWAP)
-            {
-                str += "swap";
-                str += LABELSTACK_DELIMITER;
-            }
-            else if (outseg_type == SAI_OUTSEG_TYPE_PUSH)
-            {
-                str += "push";
-                str += LABELSTACK_DELIMITER;
-            }
-            str += label_stack.to_string() + LABELSTACK_DELIMITER;
+            label_stack.to_string() + LABELSTACK_DELIMITER;
         }
         return str;
     }
diff --git a/tests/test_mpls.py b/tests/test_mpls.py
index f637e5325c..ec608d3650 100644
--- a/tests/test_mpls.py
+++ b/tests/test_mpls.py
@@ -270,7 +270,7 @@ def test_RouteAddRemoveIpRoutePush(self, dvs, testlog):
         # add route entry
         prefix = "2.2.2.0/24"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "push+201"}
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "push201"}
             self.create_route_entry(prefix, fieldValues)
         else:
             # dvs.runcmd("ip route add 2.2.2.0/24 encap mpls 201 via inet 10.0.0.1 dev Ethernet0")
@@ -305,7 +305,7 @@ def test_RouteAddRemoveMplsRouteSwap(self, dvs, testlog):
         # add route entry
         label = "200"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+201", "mpls_pop": "1"}
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap201", "mpls_pop": "1"}
             self.create_inseg_entry(label, fieldValues)
         else:
             # dvs.runcmd("ip -f mpls route add 200 as 201 via inet 10.0.0.1 dev Ethernet0")
@@ -376,7 +376,7 @@ def test_RouteAddRemoveMplsRouteExplicitNull(self, dvs, testlog):
         # add route entry
         label = "200"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+0", "mpls_pop": "1"}
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap0", "mpls_pop": "1"}
             self.create_inseg_entry(label, fieldValues)
         else:
             # dvs.runcmd("ip -f mpls route add 200 as 0 via inet 10.0.0.1 dev Ethernet0")
@@ -411,7 +411,7 @@ def test_RouteAddRemoveIpRoutePushNHG(self, dvs, testlog):
         # add route entry
         prefix = "2.2.2.0/24"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push+200,push+201"}
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push200,push201"}
             self.create_route_entry(prefix, fieldValues)
         else:
             dvs.runcmd("ip route add 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop encap mpls 201 via inet 10.0.0.5 dev Ethernet8")
@@ -449,7 +449,7 @@ def test_RouteAddRemoveMplsRouteSwapNHG(self, dvs, testlog):
         # add route entry
         label = "200"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "swap+201,swap+202", "mpls_pop": "1"}
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "swap201,swap202", "mpls_pop": "1"}
             self.create_inseg_entry(label, fieldValues)
         else:
             dvs.runcmd("ip -f mpls route add 200 nexthop as 201 via inet 10.0.0.1 dev Ethernet0 nexthop as 202 via inet 10.0.0.5 dev Ethernet8")
@@ -526,7 +526,7 @@ def test_RouteAddRemoveIpRouteMixedNHG(self, dvs, testlog):
         # add route entry
         prefix = "2.2.2.0/24"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push+200,na"}
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "push200,na"}
             self.create_route_entry(prefix, fieldValues)
         else:
             dvs.runcmd("ip route add 2.2.2.0/24 nexthop encap mpls 200 via inet 10.0.0.1 dev Ethernet0 nexthop via inet 10.0.0.5 dev Ethernet8")
@@ -565,7 +565,7 @@ def test_RouteAddRemoveMplsRouteMixedNHG(self, dvs, testlog):
         # add route entry
         label = "200"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "na,swap+201", "mpls_pop": "1"}
+            fieldValues = {"nexthop": "10.0.0.1,10.0.0.5", "ifname": "Ethernet0,Ethernet8", "mpls_nh": "na,swap201", "mpls_pop": "1"}
             self.create_inseg_entry(label, fieldValues)
         else:
             dvs.runcmd("ip -f mpls route add 200 nexthop via inet 10.0.0.1 dev Ethernet0 nexthop as 201 via inet 10.0.0.5 dev Ethernet8")
@@ -604,7 +604,7 @@ def test_RouteUnresolvedMplsRouteSwap(self, dvs, testlog):
         # add route entry
         label = "200"
         if self.mpls_appdb_mode():
-            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap+201", "mpls_pop": "1"}
+            fieldValues = {"nexthop": "10.0.0.1", "ifname": "Ethernet0", "mpls_nh": "swap201", "mpls_pop": "1"}
             self.create_inseg_entry(label, fieldValues)
         else:
             # dvs.runcmd("ip -f mpls route add 200 as 201 via inet 10.0.0.1 dev Ethernet0")