✨ feat(DPISDN-32): Classifier Node supports dynamically loading rules from mrglobal.dynamic.conf

Classifier Node supports dynamically loading rules from mrglobal.dynamic.conf

10 files changed, 153 insertions, 621 deletions

diff --git a/.gitignore b/.gitignore
index cd76df8..396968f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,7 +16,7 @@ tags
 
 __pycache__
 mpack*/
-mrglobal.conf
+mrglobal*.conf
 build*/
 test/test
 /*.opendb
diff --git a/infra/include/pkt_classifier_engine.h b/infra/include/pkt_classifier_engine.h
index 0add045..3ce0393 100644
--- a/infra/include/pkt_classifier_engine.h
+++ b/infra/include/pkt_classifier_engine.h
@@ -44,13 +44,12 @@ struct rule_list_engine
     struct rule_field_engine rules[MAX_RULES];
 };
 
-typedef void pkt_classifier_engine_t;
-extern pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
-                                                              uint32_t nr_domains, enum ruleset_type type);
-extern int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_list_engine * rule_list_engine,
-                                       char * str_error_reason, unsigned int sz_error_reason);
-extern int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance, uint32_t lcore_id,
-                                             struct rte_mbuf ** mbufs, uint16_t nr_mbufs,
-                                             uint16_t * pattern_group_id_list, struct match_result_engine * result);
-extern enum ruleset_type pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine_t * engine);
-extern void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance);
+struct pkt_classifier_engine;
+struct pkt_classifier_engine * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
+                                                            uint32_t nr_domains, enum ruleset_type type);
+int pkt_classifier_engine_build(struct pkt_classifier_engine * engine, struct rule_list_engine * rule_list_engine);
+int pkt_classifier_engine_multi_match(struct pkt_classifier_engine * engine_instance, uint32_t lcore_id,
+                                      struct rte_mbuf ** mbufs, uint16_t nr_mbufs, uint16_t * pattern_group_id_list,
+                                      struct match_result_engine * result);
+enum ruleset_type pkt_classifier_engine_get_ruleset_type(struct pkt_classifier_engine * engine);
+void pkt_classifier_engine_info_dump(struct pkt_classifier_engine * engine_instance);
diff --git a/infra/include/rpc.h b/infra/include/rpc.h
index ce0a8a2..7288d5f 100644
--- a/infra/include/rpc.h
+++ b/infra/include/rpc.h
@@ -23,11 +23,6 @@
 #define RPC_CLIENT_SYNC_ERROR_RECV -3
 
 /************************************** Topic Field **************************************/
-/* Dynamic Classifier Rule Topic */
-#ifndef PKT_CLASSIFIER_RULE_FULL_UPDATE
-#define PKT_CLASSIFIER_RULE_FULL_UPDATE "FullUpdate"
-#endif
-
 /* Dynamic Load Balance Topic */
 #ifndef MR_LB_TOPIC_SINGLE_RULE_ADD
 #define MR_LB_TOPIC_SINGLE_RULE_ADD "LBSingleRuleAdd"
diff --git a/infra/src/pkt_classifier_engine.c b/infra/src/pkt_classifier_engine.c
index 4359b44..7cbd3d5 100644
--- a/infra/src/pkt_classifier_engine.c
+++ b/infra/src/pkt_classifier_engine.c
@@ -364,8 +364,7 @@ int rule_validity_check(struct rule_field_engine rules[], uint32_t nr_rules, uin
     return RT_SUCCESS;
 }
 
-int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules, char * str_error_reason,
-                          unsigned int sz_error_reason)
+int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules)
 {
     for (uint32_t rule_index = 0; rule_index < nr_rules; rule_index++)
     {
@@ -413,7 +412,7 @@ int duplicate_rules_check(struct rule_field_engine * rules, uint32_t nr_rules, c
                     continue;
             }
 
-            sprintf(str_error_reason, "Duplicate rule %d and %d", rule_index, index);
+            MR_ERROR("Pkt classifier engine build failed, reason: duplicate rules %d and %d.", rule_index, index);
             return RT_ERR;
         }
     }
@@ -926,8 +925,7 @@ void domain_array_free_for_linear_search(struct filter_engine * filter_engine)
 }
 
 /* Create domain array */
-int domain_array_create(struct filter_engine * filter_engine, struct rule_field_engine * rules, uint32_t nr_rules,
-                        char * str_error_reason, unsigned int sz_error_reason)
+int domain_array_create(struct filter_engine * filter_engine, struct rule_field_engine * rules, uint32_t nr_rules)
 {
     /* Define the domain instance create function based on the engine type */
     domain_create fn_domain_create;
@@ -940,7 +938,7 @@ int domain_array_create(struct filter_engine * filter_engine, struct rule_field_
         fn_domain_create = domain_create_for_linear_search;
         break;
     default:
-        snprintf(str_error_reason, sz_error_reason - 1, "Unsupported engine type %d", filter_engine->type);
+        MR_ERROR("Pkt classifier engine build failed, reason: unsupported engine type %d.", filter_engine->type);
         return RT_ERR;
     }
 
@@ -968,8 +966,9 @@ int domain_array_create(struct filter_engine * filter_engine, struct rule_field_
         struct domain * domain = fn_domain_create(domain_rules, nr_rules_in_domain, domain_index);
         if (domain == NULL)
         {
-            snprintf(str_error_reason, sz_error_reason - 1, "Failed to create domain instance,the domain field is: %d",
-                     domain_index);
+            MR_ERROR(
+                "Pkt classifier engine build failed, reason: failed to create domain instance,the domain field is: %d.",
+                domain_index);
             return RT_ERR;
         }
 
@@ -995,8 +994,7 @@ void domain_array_free(struct filter_engine * filter_engine)
 
 /* Create a new filter engine instance based on the engine type and engine rule list. */
 struct filter_engine * filter_engine_create(struct rule_field_engine * rules, uint32_t nr_rules, uint32_t nr_domains,
-                                            enum engine_algo_type type, char * str_error_reason,
-                                            unsigned int sz_error_reason)
+                                            enum engine_algo_type type)
 {
     /* Allocate memory for the engine. */
     struct filter_engine * filter_engine = ZMALLOC(sizeof(struct filter_engine));
@@ -1005,7 +1003,7 @@ struct filter_engine * filter_engine_create(struct rule_field_engine * rules, ui
     filter_engine->nr_domains = nr_domains;
 
     /* Create the pattern groups based on the engine type and engine rule list. */
-    int ret = domain_array_create(filter_engine, rules, nr_rules, str_error_reason, sz_error_reason);
+    int ret = domain_array_create(filter_engine, rules, nr_rules);
     if (ret != RT_SUCCESS)
     {
         domain_array_free(filter_engine);
@@ -1022,8 +1020,8 @@ void filter_engine_free(struct filter_engine * filter_engine)
 }
 
 /* Public func */
-pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
-                                                       uint32_t nr_domains, enum ruleset_type type)
+struct pkt_classifier_engine * pkt_classifier_engine_create(unsigned int nr_io_thread, cpu_set_t * cpu_set_io,
+                                                            uint32_t nr_domains, enum ruleset_type type)
 {
     /* Check the ruleset type */
     if (type >= RULESET_TYPE_MAX)
@@ -1050,22 +1048,22 @@ pkt_classifier_engine_t * pkt_classifier_engine_create(unsigned int nr_io_thread
         rte_rcu_qsbr_thread_register(engine->qsv, lcore_id);
     }
 
-    return (pkt_classifier_engine_t *)engine;
+    return engine;
 }
 
-enum ruleset_type pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine_t * engine)
+enum ruleset_type pkt_classifier_engine_get_ruleset_type(struct pkt_classifier_engine * engine)
 {
-    return ((struct pkt_classifier_engine *)engine)->ruleset_type;
+    return engine->ruleset_type;
 }
 
-enum engine_algo_type get_engine_type(pkt_classifier_engine_t * engine)
+enum engine_algo_type get_engine_type(struct pkt_classifier_engine * engine)
 {
-    return ((struct pkt_classifier_engine *)engine)->filter_engine->type;
+    return engine->filter_engine->type;
 }
 
-void pkt_classifier_engine_fast_match_info_dump(pkt_classifier_engine_t * engine)
+void pkt_classifier_engine_fast_match_info_dump(struct pkt_classifier_engine * engine)
 {
-    struct filter_engine * filter_engine = ((struct pkt_classifier_engine *)engine)->filter_engine;
+    struct filter_engine * filter_engine = engine->filter_engine;
     for (uint16_t index = 0; index < RTE_DIM(filter_engine->domains); index++)
     {
         char str_info[2048] = {};
@@ -1110,20 +1108,18 @@ void pkt_classifier_engine_fast_match_info_dump(pkt_classifier_engine_t * engine
 }
 
 /* Build the classifier engine based on 'rule_field_engine'. */
-int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_list_engine * rule_list_engine,
-                                char * str_error_reason, unsigned int sz_error_reason)
+int pkt_classifier_engine_build(struct pkt_classifier_engine * engine, struct rule_list_engine * rule_list_engine)
 {
     /* Rule validity check. */
-    struct pkt_classifier_engine * pkt_classifier_engine = (struct pkt_classifier_engine *)engine;
     uint16_t nr_rules = rule_list_engine->nr_rules;
-    uint32_t nr_domains = pkt_classifier_engine->nr_domains;
+    uint32_t nr_domains = engine->nr_domains;
     struct rule_field_engine * rules = rule_list_engine->rules;
     int ret = rule_validity_check(rules, nr_rules, nr_domains);
     if (ret != RT_SUCCESS)
         return RT_ERR;
 
     /* Duplicate rules check. */
-    ret = duplicate_rules_check(rules, nr_rules, str_error_reason, sz_error_reason);
+    ret = duplicate_rules_check(rules, nr_rules);
     if (ret != RT_SUCCESS)
         return RT_ERR;
 
@@ -1131,19 +1127,18 @@ int pkt_classifier_engine_build(pkt_classifier_engine_t * engine, struct rule_li
     enum engine_algo_type engine_algo_type = (nr_rules > 100) ? ENGINE_TYPE_TREE_SEARCH : ENGINE_TYPE_LINEAR_SEARCH;
 
     /* Initialize a new filter engine */
-    struct filter_engine * filter_engine_new =
-        filter_engine_create(rules, nr_rules, nr_domains, engine_algo_type, str_error_reason, sz_error_reason);
+    struct filter_engine * filter_engine_new = filter_engine_create(rules, nr_rules, nr_domains, engine_algo_type);
     if (filter_engine_new == NULL)
         return RT_ERR;
 
     /* Retrieve the old filter engine*/
-    struct filter_engine * filter_engine_old = pkt_classifier_engine->filter_engine;
+    struct filter_engine * filter_engine_old = engine->filter_engine;
 
     /* Update the filter engine */
-    pkt_classifier_engine->filter_engine = filter_engine_new;
+    engine->filter_engine = filter_engine_new;
 
     /* Synchronize RCU and free the old filter engine */
-    rte_rcu_qsbr_synchronize(pkt_classifier_engine->qsv, RTE_QSBR_THRID_INVALID);
+    rte_rcu_qsbr_synchronize(engine->qsv, RTE_QSBR_THRID_INVALID);
     if (filter_engine_old != NULL)
         filter_engine_free(filter_engine_old);
 
@@ -1500,7 +1495,7 @@ void packets_match(struct filter_engine * filter_engine, struct rte_mbuf * mbufs
 }
 
 /* Match multiple packets with the Packet Classifier Engine */
-int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance, uint32_t lcore_id,
+int pkt_classifier_engine_multi_match(struct pkt_classifier_engine * engine, uint32_t lcore_id,
                                       struct rte_mbuf * mbufs[], uint16_t nr_mbufs, uint16_t domain_field_for_pkts[],
                                       struct match_result_engine result[])
 {
@@ -1508,7 +1503,6 @@ int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance,
     assert(nr_mbufs <= 16);
 
     /* Set rcu thread online */
-    struct pkt_classifier_engine * engine = (struct pkt_classifier_engine *)engine_instance;
     struct rte_rcu_qsbr * qsv = engine->qsv;
     rte_rcu_qsbr_thread_online(qsv, lcore_id);
 
@@ -1523,13 +1517,13 @@ int pkt_classifier_engine_multi_match(pkt_classifier_engine_t * engine_instance,
 }
 
 /* Dump all rules information. */
-void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance)
+void pkt_classifier_engine_info_dump(struct pkt_classifier_engine * engine)
 {
     /* Dump the fast match info */
-    pkt_classifier_engine_fast_match_info_dump(engine_instance);
+    pkt_classifier_engine_fast_match_info_dump(engine);
 
     /* Dump the ruleset type */
-    enum ruleset_type ruleset_type = pkt_classifier_engine_get_ruleset_type(engine_instance);
+    enum ruleset_type ruleset_type = pkt_classifier_engine_get_ruleset_type(engine);
     if (ruleset_type == RULESET_TYPE_CLASSIFIER)
     {
         MR_INFO("Pkt classifier ruleset type: Classifier");
@@ -1540,7 +1534,7 @@ void pkt_classifier_engine_info_dump(pkt_classifier_engine_t * engine_instance)
     }
 
     /* Dump the engine type */
-    enum engine_algo_type engine_algo_type = get_engine_type(engine_instance);
+    enum engine_algo_type engine_algo_type = get_engine_type(engine);
     if (engine_algo_type == ENGINE_TYPE_TREE_SEARCH)
     {
         MR_INFO("Pkt classifier engine type: Tree search");
diff --git a/infra/test/TestPktClassifierEngine.cc b/infra/test/TestPktClassifierEngine.cc
index 03b4fd3..7652cc7 100644
--- a/infra/test/TestPktClassifierEngine.cc
+++ b/infra/test/TestPktClassifierEngine.cc
@@ -21,7 +21,7 @@ class TestCasePktClassifierEngine : public ::testing::Test
 {
   protected:
     static struct rte_mempool * pktmbuf_pool_;
-    static pkt_classifier_engine_t * engine_instance_;
+    static struct pkt_classifier_engine * engine_instance_;
     static void SetUpTestCase()
     {
         unsigned int sz_align_priv = RTE_ALIGN(64, RTE_MBUF_PRIV_ALIGN);
@@ -45,7 +45,7 @@ class TestCasePktClassifierEngine : public ::testing::Test
 };
 
 struct rte_mempool * TestCasePktClassifierEngine::pktmbuf_pool_ = nullptr;
-pkt_classifier_engine_t * TestCasePktClassifierEngine::engine_instance_ = nullptr;
+struct pkt_classifier_engine * TestCasePktClassifierEngine::engine_instance_ = nullptr;
 
 void construct_pkt_for_ipv4(struct rte_mbuf * mbuf, char * src_addr, char * dst_addr, uint8_t proto, uint16_t src_port,
                             uint16_t dst_port)
@@ -215,13 +215,7 @@ TEST_F(TestCasePktClassifierEngine, PktFullFieldMatchForLinearSearch)
     rule_list_engine_generator_for_full_field_match(100, &rule_list_engine);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -291,13 +285,7 @@ TEST_F(TestCasePktClassifierEngine, PktFullFieldMatchForTreeSearch)
     rule_list_engine_generator_for_full_field_match(200, &rule_list_engine);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -439,13 +427,7 @@ TEST_F(TestCasePktClassifierEngine, IPAddrTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:2:2:2:2:2", &rule->dst_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the packet */
@@ -636,13 +618,7 @@ TEST_F(TestCasePktClassifierEngine, IPAddrTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -813,13 +789,7 @@ TEST_F(TestCasePktClassifierEngine, ProtoTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:2:2:2:2:2", &rule->dst_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -986,13 +956,7 @@ TEST_F(TestCasePktClassifierEngine, ProtoTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1103,13 +1067,7 @@ TEST_F(TestCasePktClassifierEngine, PortTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1224,13 +1182,7 @@ TEST_F(TestCasePktClassifierEngine, PortTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1361,13 +1313,7 @@ TEST_F(TestCasePktClassifierEngine, DomainTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1534,13 +1480,7 @@ TEST_F(TestCasePktClassifierEngine, DomainTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -1759,13 +1699,7 @@ TEST_F(TestCasePktClassifierEngine, PriorityTestForLinearSearch)
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2000,13 +1934,7 @@ TEST_F(TestCasePktClassifierEngine, PriorityTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2106,13 +2034,7 @@ TEST_F(TestCasePktClassifierEngine, RepeatBuildTest)
         }
 
         /* Build the engine */
-        char str_error_reason[MR_STRING_MAX];
-        int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason,
-                                              sizeof(str_error_reason));
-        if (ret != 0)
-        {
-            printf("error reason: %s\n", str_error_reason);
-        }
+        int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
         EXPECT_EQ(ret, 0);
     }
 }
@@ -2158,13 +2080,8 @@ TEST_F(TestCasePktClassifierEngine, DuplicateRulesCheckTest)
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
+
     EXPECT_EQ(ret, -1);
 }
 
@@ -2247,13 +2164,7 @@ TEST_F(TestCasePktClassifierEngine, IcmpTestForLinearSearch)
     rule->dst_addr_mask_len = 0;
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2424,13 +2335,7 @@ TEST_F(TestCasePktClassifierEngine, IcmpTestForTreeSearch)
     }
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    int ret =
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
-    if (ret != 0)
-    {
-        printf("error reason: %s\n", str_error_reason);
-    }
+    int ret = pkt_classifier_engine_build(engine_instance_, &rule_list_engine);
     EXPECT_EQ(ret, 0);
 
     /* Create the pkts */
@@ -2529,9 +2434,8 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
 
     /* Build the engine */
-    char str_error_reason[MR_STRING_MAX];
-    ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        ASSERT_DEATH(
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The proto mask is invalid */
@@ -2551,7 +2455,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The priority is invalid */
@@ -2571,7 +2475,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The domain is invalid */
@@ -2591,7 +2495,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The src port start is invalid */
@@ -2611,7 +2515,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The dst port start is invalid */
@@ -2631,7 +2535,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv4 src addr mask len is invalid */
@@ -2651,7 +2555,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv4 dst addr mask len is invalid */
@@ -2671,7 +2575,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 33;
     inet_pton(AF_INET, "172.17.1.1", &rule->src_addr_v4);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv6 src addr mask len is invalid */
@@ -2691,7 +2595,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 0;
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 
     /* The ipv6 dst addr mask len is invalid */
@@ -2711,7 +2615,7 @@ TEST_F(TestCasePktClassifierEngine, RuleValidityCheckTest)
     rule->dst_addr_mask_len = 129;
     inet_pton(AF_INET6, "2001:db8:0:1:1:1:1:1", &rule->src_addr_v6);
     ASSERT_DEATH(
-        pkt_classifier_engine_build(engine_instance_, &rule_list_engine, str_error_reason, sizeof(str_error_reason)),
+        pkt_classifier_engine_build(engine_instance_, &rule_list_engine),
         ".*");
 }
 #endif
diff --git a/service/include/sc_classifier_rule_parser.h b/service/include/sc_classifier_rule_parser.h
index a2c3b41..cd07dbe 100644
--- a/service/include/sc_classifier_rule_parser.h
+++ b/service/include/sc_classifier_rule_parser.h
@@ -69,13 +69,11 @@ struct rule_field_parser
 struct rule_list_parsed
 {
     uint16_t nr_rules;
-    uint16_t nr_local_rules;
-    uint16_t nr_remote_rules;
     struct rule_field_parser rules[MAX_RULES];
 };
 
-extern int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type,
-                                            struct rule_list_parsed * out_rule_list);
+extern int pkt_classifier_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type,
+                                      struct rule_list_parsed * out_rule_list);
 extern int pkt_classifier_remote_rule_parser(cJSON * c_rule, struct rule_list_parsed * out_rule_list,
                                              char * str_error_reason, unsigned int sz_error_reason);
 extern void classifier_rule_dump(struct rule_list_parsed * rule_list);
diff --git a/service/include/sc_common.h b/service/include/sc_common.h
index feb7733..d345e10 100644
--- a/service/include/sc_common.h
+++ b/service/include/sc_common.h
@@ -134,8 +134,6 @@ struct sc_main
     struct vlan_base_fwd_main * vlan_base_fwd_main;
     /* Node Manager */
     struct node_manager_main * node_mgr_main;
-    /* Classifier Node */
-    struct node_classifier_main * node_classifier_main;
     /* Failover Node */
     struct node_lb_main * lb_node_main;
     /* Etherfabric Node */
diff --git a/service/src/classifier_rule_parser.c b/service/src/classifier_rule_parser.c
index 9ba95ab..f8ebd5c 100644
--- a/service/src/classifier_rule_parser.c
+++ b/service/src/classifier_rule_parser.c
@@ -3,8 +3,8 @@
 #include <limits.h>
 #include <sc_classifier_rule_parser.h>
 
-int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type,
-                                     struct rule_list_parsed * out_rule_list)
+int pkt_classifier_rule_parser(struct sc_main * sc, enum ruleset_type ruleset_type,
+                               struct rule_list_parsed * out_rule_list)
 {
     int ret = RT_SUCCESS;
     for (int rule_index = 0; rule_index < MAX_RULES; rule_index++)
@@ -13,7 +13,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
         uint32_t rule_id;
         char str_section[MR_SYMBOL_MAX] = {};
         snprintf(str_section, sizeof(str_section), "classifier_rule:%d", rule_index);
-        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_id);
+        ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "rule_id", &rule_id);
         if (ret < 0)
         {
             continue;
@@ -21,7 +21,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve the ruleset type; if there's no configured ruleset, break the current rule */
         char str_ruleset_type[MR_SYMBOL_MAX] = {};
-        ret = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "ruleset_type", str_ruleset_type,
+        ret = MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "ruleset_type", str_ruleset_type,
                                              sizeof(str_ruleset_type));
         if (ret < 0)
         {
@@ -61,7 +61,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve the proto */
         char str_proto[MR_SYMBOL_MAX] = {};
-        MESA_load_profile_string_def(sc->local_cfgfile, str_section, "proto", str_proto, sizeof(str_proto), "any");
+        MESA_load_profile_string_def(sc->local_dyfile, str_section, "proto", str_proto, sizeof(str_proto), "any");
         if (strcmp(str_proto, "tcp") == 0)
         {
             rule_field_parser.proto = IPPROTO_TCP;
@@ -81,10 +81,10 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve source port start and end */
         uint32_t src_port_range_start = 0, src_port_range_end = 0;
-        int ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_start",
-                                                   &src_port_range_start, 0);
-        int ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_end",
-                                                 &src_port_range_end, 65535);
+        int ret_start =
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_port_range_start", &src_port_range_start, 0);
+        int ret_end =
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_port_range_end", &src_port_range_end, 65535);
         if ((ret_start >= 0) && (ret_end < 0))
         {
             src_port_range_end = src_port_range_start;
@@ -99,10 +99,10 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve destination port start and end */
         uint32_t dst_port_range_start = 0, dst_port_range_end = 0;
-        ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_start",
-                                               &dst_port_range_start, 0);
-        ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_end", &dst_port_range_end,
-                                             65535);
+        ret_start =
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_port_range_start", &dst_port_range_start, 0);
+        ret_end =
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_port_range_end", &dst_port_range_end, 65535);
         if ((ret_start >= 0) && (ret_end < 0))
         {
             dst_port_range_end = dst_port_range_start;
@@ -117,7 +117,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve the priority */
         uint32_t priority;
-        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "priority", &priority);
+        ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "priority", &priority);
         if (ret < 0)
         {
             MR_ERROR("Pkt classifier rule name : %s ,must config the 'priority'.", str_section);
@@ -134,7 +134,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
 
         /* Retrieve the IPv4 source address and mask*/
         char str_src_ip_addr_v4[MR_SYMBOL_MAX] = {};
-        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v4", str_src_ip_addr_v4,
+        if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "src_ip_addr_v4", str_src_ip_addr_v4,
                                            sizeof(str_src_ip_addr_v4)) > 0)
         {
             rule_field_parser.ether_type = RTE_ETHER_TYPE_IPV4;
@@ -147,13 +147,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
                 return RT_ERR;
             }
 
-            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v4",
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_ip_mask_v4",
                                        &rule_field_parser.src_addr_mask_len, 32);
         }
 
         /* Retrieve the IPv4 destination address and mask */
         char str_dst_ip_addr_v4[MR_SYMBOL_MAX] = {};
-        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4,
+        if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4,
                                            sizeof(str_dst_ip_addr_v4)) > 0)
         {
             rule_field_parser.ether_type = RTE_ETHER_TYPE_IPV4;
@@ -165,13 +165,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
                 return RT_ERR;
             }
 
-            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v4",
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_ip_mask_v4",
                                        &rule_field_parser.dst_addr_mask_len, 32);
         }
 
         /* Retrieve the IPv6 source address and mask  */
         char str_src_ip_addr_v6[MR_SYMBOL_MAX] = {};
-        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v6", str_src_ip_addr_v6,
+        if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "src_ip_addr_v6", str_src_ip_addr_v6,
                                            sizeof(str_src_ip_addr_v6)) > 0)
         {
             /* Verify the IP version */
@@ -190,13 +190,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
                 return RT_ERR;
             }
 
-            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v6",
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "src_ip_mask_v6",
                                        &rule_field_parser.src_addr_mask_len, 128);
         }
 
         /* Retrieve the IPv6 destination address and mask  */
         char str_dst_ip_addr_v6[MR_SYMBOL_MAX] = {};
-        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v6", str_dst_ip_addr_v6,
+        if (MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "dst_ip_addr_v6", str_dst_ip_addr_v6,
                                            sizeof(str_dst_ip_addr_v6)) > 0)
         {
             /* Verify the IP version */
@@ -215,13 +215,13 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
                 return RT_ERR;
             }
 
-            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v6",
+            MESA_load_profile_uint_def(sc->local_dyfile, str_section, "dst_ip_mask_v6",
                                        &rule_field_parser.dst_addr_mask_len, 128);
         }
 
         /* Retrieve the action */
         char str_action[MR_SYMBOL_MAX] = {};
-        ret = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "action", str_action, sizeof(str_action));
+        ret = MESA_load_profile_string_nodef(sc->local_dyfile, str_section, "action", str_action, sizeof(str_action));
         if (ret < 0)
         {
             MR_ERROR("Pkt classifier rule name : %s ,no config the 'action'.", str_section);
@@ -248,7 +248,7 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
         {
             /* Retrieve the SID */
             uint32_t sid = 0;
-            ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "sid", &sid);
+            ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "sid", &sid);
             if (ret < 0)
             {
                 MR_ERROR("Pkt classifier rule name : %s ,no config the 'sid'.", str_section);
@@ -261,9 +261,9 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
             uint32_t ef_adapter_id = UINT32_MAX;
             uint32_t vwire_adapter_id = UINT32_MAX;
             uint32_t tera_adapter_id = UINT32_MAX;
-            int ef_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "ef_id", &ef_adapter_id);
-            int vwire_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "vwire_id", &vwire_adapter_id);
-            int tera_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "tera_id", &tera_adapter_id);
+            int ef_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "ef_id", &ef_adapter_id);
+            int vwire_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "vwire_id", &vwire_adapter_id);
+            int tera_ret = MESA_load_profile_uint_nodef(sc->local_dyfile, str_section, "tera_id", &tera_adapter_id);
 
             if (ef_ret >= 0)
             {
@@ -292,7 +292,6 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
         memcpy(rule_field_item, &rule_field_parser, sizeof(struct rule_field_parser));
 
         out_rule_list->nr_rules++;
-        out_rule_list->nr_local_rules++;
         if (out_rule_list->nr_rules >= MAX_RULES)
         {
             MR_ERROR("Pkt classifier rule name : %s , ruleset type is '%s', rules is full.", str_section,
@@ -303,325 +302,6 @@ int pkt_classifier_local_rule_parser(struct sc_main * sc, enum ruleset_type rule
     return RT_SUCCESS;
 }
 
-int parse_ip_version_from_cjson(cJSON * c_rule, uint16_t * ip_version)
-{
-    cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(c_rule, "SrcIpV4");
-    cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(c_rule, "DstIpV4");
-    cJSON * cj_src_ip_addr_v6 = cJSON_GetObjectItem(c_rule, "SrcIpV6");
-    cJSON * cj_dst_ip_addr_v6 = cJSON_GetObjectItem(c_rule, "DstIpV6");
-
-    if (((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL)) &&
-        ((cj_src_ip_addr_v6 != NULL) || (cj_dst_ip_addr_v6 != NULL)))
-        return RT_ERR;
-
-    if ((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL))
-        *ip_version = RTE_ETHER_TYPE_IPV4;
-    else if ((cj_src_ip_addr_v6 != NULL) || (cj_dst_ip_addr_v6 != NULL))
-        *ip_version = RTE_ETHER_TYPE_IPV6;
-    else
-        *ip_version = UINT16_MAX;
-
-    return RT_SUCCESS;
-}
-
-int pkt_classifier_remote_rule_parser(cJSON * cjson_rule, struct rule_list_parsed * out_rule_list,
-                                      char * str_error_reason, unsigned int sz_error_reason)
-{
-    /* Retrieve the rule array */
-    cJSON * cj_rule_array = cJSON_GetObjectItem(cjson_rule, "RuleArray");
-    if (cj_rule_array == NULL)
-    {
-        snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, no config 'RuleArray'.");
-        return RT_ERR;
-    }
-
-    /* Retrieve the rules number */
-    int nr_rules = cJSON_GetArraySize(cj_rule_array);
-    for (int rule_index = 0; rule_index < nr_rules; rule_index++)
-    {
-        /* Initialize rule field with default values */
-        struct rule_field_parser rule_field_parser = {};
-        rule_field_parser.src_port_start = 0;
-        rule_field_parser.src_port_end = 65535;
-        rule_field_parser.dst_port_start = 0;
-        rule_field_parser.dst_port_end = 65535;
-        rule_field_parser.ether_type = UINT16_MAX;
-
-        /* Get IP Version */
-        cJSON * cj_rule_item = cJSON_GetArrayItem(cj_rule_array, rule_index);
-        int ret = parse_ip_version_from_cjson(cj_rule_item, &rule_field_parser.ether_type);
-        if (ret != RT_SUCCESS)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1,
-                     "Classifier rule add error, configuring both IPv4 and IPv6 simultaneously.");
-            return RT_ERR;
-        }
-
-        /* Parse rule field information from the total JSON data */
-        /* rule id */
-        cJSON * cj_rule_id = cJSON_GetObjectItem(cj_rule_item, "RuleId");
-        /* IP */
-        cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(cj_rule_item, "SrcIpV4");
-        cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(cj_rule_item, "DstIpV4");
-        cJSON * cj_src_ip_addr_v6 = cJSON_GetObjectItem(cj_rule_item, "SrcIpV6");
-        cJSON * cj_dst_ip_addr_v6 = cJSON_GetObjectItem(cj_rule_item, "DstIpV6");
-        /* IP Mask */
-        cJSON * cj_src_ip_mask = cJSON_GetObjectItem(cj_rule_item, "SrcIpMask");
-        cJSON * cj_dst_ip_mask = cJSON_GetObjectItem(cj_rule_item, "DstIpMask");
-        /* Port */
-        cJSON * cj_src_port_range_start = cJSON_GetObjectItem(cj_rule_item, "SrcPortLow");
-        cJSON * cj_src_port_range_end = cJSON_GetObjectItem(cj_rule_item, "SrcPortHigh");
-        cJSON * cj_dst_port_range_start = cJSON_GetObjectItem(cj_rule_item, "DstPortLow");
-        cJSON * cj_dst_port_range_end = cJSON_GetObjectItem(cj_rule_item, "DstPortHigh");
-        /* Proto */
-        cJSON * cj_proto = cJSON_GetObjectItem(cj_rule_item, "Proto");
-        /* Priority */
-        // cJSON * cj_priority = cJSON_GetObjectItem(cj_rule_item, "Priority");
-        /* Category */
-        cJSON * cj_category = cJSON_GetObjectItem(cj_rule_item, "Category");
-        /* Sid */
-        cJSON * cj_sid = cJSON_GetObjectItem(cj_rule_item, "Sid");
-        /* Vwire id */
-        cJSON * cj_vwire_id = cJSON_GetObjectItem(cj_rule_item, "VwireId");
-        /* Ef id */
-        cJSON * cj_ef_id = cJSON_GetObjectItem(cj_rule_item, "EfId");
-        /* Tera id */
-        cJSON * cj_tera_id = cJSON_GetObjectItem(cj_rule_item, "TeraId");
-
-        /* Verify required rule field: rule ID */
-        uint32_t rule_id;
-        if (cj_rule_id == NULL)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error,no config rule id .");
-            return RT_ERR;
-        }
-        else
-        {
-            rule_id = (uint32_t)cj_rule_id->valuedouble;
-        }
-
-        /* Verify required rule field: priority */
-#if 0
-        if (cj_priority == NULL)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1,
-                     "Classifier rule add error, rule ID '%u', 'priority' not configured.", rule_id);
-            return RT_ERR;
-        }
-#else
-        if (cj_category == NULL)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1,
-                     "Classifier rule add error, rule ID '%u', 'category' not configured.", rule_id);
-            return RT_ERR;
-        }
-#endif
-
-        /* Verify the mandatory rule field: SID */
-        if (cj_sid == NULL)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error,rule id '%u',no config 'sid' .",
-                     rule_id);
-            return RT_ERR;
-        }
-
-        /* Retrieve protocol */
-        if (cj_proto != NULL)
-        {
-            rule_field_parser.proto = (uint8_t)cj_proto->valuedouble;
-            rule_field_parser.proto_mask = UINT8_MAX;
-        }
-
-        /* Retrieve source port start and end */
-        if (cj_src_port_range_start != NULL)
-            rule_field_parser.src_port_start = (uint16_t)cj_src_port_range_start->valuedouble;
-
-        if (cj_src_port_range_end != NULL)
-            rule_field_parser.src_port_end = (uint16_t)cj_src_port_range_end->valuedouble;
-
-        if ((cj_src_port_range_start != NULL) && (cj_src_port_range_end == NULL))
-        {
-            rule_field_parser.src_port_end = rule_field_parser.src_port_start;
-        }
-        else if ((cj_src_port_range_start == NULL) && (cj_src_port_range_end != NULL))
-        {
-            rule_field_parser.src_port_start = rule_field_parser.src_port_end;
-        }
-
-        /* Retrieve destination port start and end */
-        if (cj_dst_port_range_start != NULL)
-            rule_field_parser.dst_port_start = (uint16_t)cj_dst_port_range_start->valuedouble;
-
-        if (cj_dst_port_range_end != NULL)
-            rule_field_parser.dst_port_end = (uint16_t)cj_dst_port_range_end->valuedouble;
-
-        if ((cj_dst_port_range_start != NULL) && (cj_dst_port_range_end == NULL))
-        {
-            rule_field_parser.dst_port_end = rule_field_parser.dst_port_start;
-        }
-        else if ((cj_dst_port_range_start == NULL) && (cj_dst_port_range_end != NULL))
-        {
-            rule_field_parser.dst_port_start = rule_field_parser.dst_port_end;
-        }
-
-        /* Retrieve the priority */
-#if 0
-
-        rule_field_parser.priority = (uint16_t)cj_priority->valuedouble;
-#else
-        rule_field_parser.priority = (uint8_t)cj_category->valuedouble;
-#endif
-
-        /* Retrieve the rule id */
-        rule_field_parser.rule_id = rule_id;
-
-        /* Retrieve IPv4 source address and mask */
-        if (cj_src_ip_addr_v4 != NULL)
-        {
-            ret = inet_pton(AF_INET, cj_src_ip_addr_v4->valuestring, &rule_field_parser.src_addr_v4);
-            if ((!ret) && (strcmp(cj_src_ip_addr_v4->valuestring, "0.0.0.0") != 0))
-            {
-                snprintf(str_error_reason, sz_error_reason - 1,
-                         "Classifier rule add error, rule ID '%u', the IPv4 source address '%s' is invalid.", rule_id,
-                         cj_src_ip_addr_v4->valuestring);
-                return RT_ERR;
-            }
-
-            /* Retrieve the source address mask */
-            if (cj_src_ip_mask != NULL)
-                rule_field_parser.src_addr_mask_len = (uint32_t)cj_src_ip_mask->valuedouble;
-            else
-                rule_field_parser.src_addr_mask_len = 32;
-        }
-
-        /* Retrieve IPv4 destination address and mask */
-        if (cj_dst_ip_addr_v4 != NULL)
-        {
-            ret = inet_pton(AF_INET, cj_dst_ip_addr_v4->valuestring, &rule_field_parser.dst_addr_v4);
-            if ((!ret) && (strcmp(cj_dst_ip_addr_v4->valuestring, "0.0.0.0") != 0))
-            {
-                snprintf(str_error_reason, sz_error_reason - 1,
-                         "Classifier rule add error, rule ID '%u', the IPv4 destination address '%s' is invalid.",
-                         rule_id, cj_dst_ip_addr_v4->valuestring);
-                return RT_ERR;
-            }
-
-            /* Retrieve the destination address mask */
-            if (cj_dst_ip_mask != NULL)
-                rule_field_parser.dst_addr_mask_len = (uint32_t)cj_dst_ip_mask->valuedouble;
-            else
-                rule_field_parser.dst_addr_mask_len = 32;
-        }
-
-        /* Retrieve IPv6 source address and mask */
-        if (cj_src_ip_addr_v6 != NULL)
-        {
-            ret = inet_pton(AF_INET6, cj_src_ip_addr_v6->valuestring, &rule_field_parser.src_addr_v6);
-            if ((!ret) && (strcmp(cj_src_ip_addr_v6->valuestring, "::") != 0))
-            {
-                snprintf(str_error_reason, sz_error_reason - 1,
-                         "Classifier rule add error, rule ID '%u', the IPv6 source address '%s' is invalid.", rule_id,
-                         cj_src_ip_addr_v6->valuestring);
-                return RT_ERR;
-            }
-
-            /* Retrieve the source address mask */
-            if (cj_src_ip_mask != NULL)
-                rule_field_parser.src_addr_mask_len = (uint32_t)cj_src_ip_mask->valuedouble;
-            else
-                rule_field_parser.src_addr_mask_len = 128;
-        }
-
-        /* Retrieve IPv6 destination address and mask */
-        if (cj_dst_ip_addr_v6 != NULL)
-        {
-            ret = inet_pton(AF_INET6, cj_dst_ip_addr_v6->valuestring, &rule_field_parser.dst_addr_v6);
-            if ((!ret) && (strcmp(cj_dst_ip_addr_v6->valuestring, "::") != 0))
-            {
-                snprintf(str_error_reason, sz_error_reason - 1,
-                         "Classifier rule add error, rule ID '%u', the IPv6 destination address '%s' is invalid.",
-                         rule_id, cj_dst_ip_addr_v6->valuestring);
-                return RT_ERR;
-            }
-
-            /* Retrieve the destination address mask */
-            if (cj_dst_ip_mask != NULL)
-                rule_field_parser.dst_addr_mask_len = (uint32_t)cj_dst_ip_mask->valuedouble;
-            else
-                rule_field_parser.dst_addr_mask_len = 128;
-        }
-
-        /* Retrieve the action */
-#if 0
-        cJSON * cj_action = cJSON_GetObjectItem(cj_rule_item, "Action");
-        if (cj_action == NULL)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', no config 'action'.",
-                     rule_id);
-            return RT_ERR;
-        }
-
-        if (strcmp(cj_action->valuestring, "drop") == 0)
-        {
-            rule_field_parser.action.type = ACTION_DROP;
-        }
-        else if (strcmp(cj_action->valuestring, "nf_steering") == 0)
-        {
-            rule_field_parser.action.type = ACTION_NF_STEERING;
-        }
-        else
-        {
-            snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', action '%s' invalid.",
-                     rule_id, cj_action->valuestring);
-            return RT_ERR;
-        }
-#else
-        rule_field_parser.action.type = ACTION_NF_STEERING;
-#endif
-        if (rule_field_parser.action.type == ACTION_NF_STEERING)
-        {
-            /* Retrieve the SID */
-            rule_field_parser.action.sid = (uint16_t)cj_sid->valuedouble;
-
-            /* Retrieve the adapter type and ID */
-            if (cj_vwire_id != NULL)
-            {
-                rule_field_parser.adapter.type = ADAPTER_TYPE_VWIRE;
-                rule_field_parser.adapter.id = (uint16_t)cj_vwire_id->valuedouble;
-            }
-            else if (cj_ef_id != NULL)
-            {
-                rule_field_parser.adapter.type = ADAPTER_TYPE_EF;
-                rule_field_parser.adapter.id = (uint16_t)cj_ef_id->valuedouble;
-            }
-            else if (cj_tera_id != NULL)
-            {
-                rule_field_parser.adapter.type = ADAPTER_TYPE_TERA;
-                rule_field_parser.adapter.id = (uint16_t)cj_tera_id->valuedouble;
-            }
-            else
-            {
-                rule_field_parser.adapter.type = ADAPTER_TYPE_ALL;
-                rule_field_parser.adapter.id = UINT16_MAX;
-            }
-        }
-
-        /* Copy the rule field information to the output rule list */
-        struct rule_field_parser * rule_field_item = &out_rule_list->rules[out_rule_list->nr_rules];
-        memcpy(rule_field_item, &rule_field_parser, sizeof(struct rule_field_parser));
-
-        out_rule_list->nr_rules++;
-        out_rule_list->nr_remote_rules++;
-        if (out_rule_list->nr_rules >= MAX_RULES)
-        {
-            snprintf(str_error_reason, sz_error_reason - 1, "Classifier rule add error, rule ID '%u', rules is full.",
-                     rule_id);
-            return RT_ERR;
-        }
-    }
-    return RT_SUCCESS;
-}
-
 /* Dump all rules information. */
 void classifier_rule_dump(struct rule_list_parsed * rule_list)
 {
@@ -711,6 +391,4 @@ void classifier_rule_dump(struct rule_list_parsed * rule_list)
 
     /* Dump the total rule number */
     MR_INFO("Pkt classifier total rules: %u", rule_list->nr_rules);
-    MR_INFO("Pkt classifier local rules: %u", rule_list->nr_local_rules);
-    MR_INFO("Pkt classifier remote rules: %u", rule_list->nr_remote_rules);
 }
diff --git a/service/src/core.c b/service/src/core.c
index 9cfaebf..9241b6a 100644
--- a/service/src/core.c
+++ b/service/src/core.c
@@ -9,10 +9,10 @@
 #include <rte_service_component.h>
 #include <rte_version.h>
 #include <signal.h>
-#include <sys/signalfd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/prctl.h>
+#include <sys/signalfd.h>
 #include <unistd.h>
 
 #include <MESA_prof_load.h>
@@ -188,6 +188,7 @@ int32_t sw_vlan_base_forward_service_entry(void * args);
 int32_t smartoffload_service_entry(void * args);
 int32_t node_manager_pkt_graph_service_entry(void * args);
 int olp_config_reload(struct sc_main * sc_main);
+int classifier_rule_update(struct sc_main * sc);
 
 int sc_check_spinlock_loop(struct sc_main * sc_main)
 {
@@ -889,7 +890,7 @@ void * config_reload_handler(void * arg)
         sleep(1);
     }
 
-    while(1)
+    while (1)
     {
         s = read(sfd, &fdsi, sizeof(fdsi));
         if (s != sizeof(fdsi))
@@ -903,6 +904,7 @@ void * config_reload_handler(void * arg)
         }
 
         olp_config_reload(g_sc_main);
+        classifier_rule_update(g_sc_main);
     }
 
     close(sfd);
diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index 4f37626..3c3fb86 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -35,29 +35,30 @@ struct node_classifier_main
     unsigned int nr_tera_adapters;
     unsigned int ignore_all_icmp_pkts;
     unsigned int ignore_all_icmp6_pkts;
-    pkt_classifier_engine_t * engine_instance;
-    struct classifier_stats stats_per_graph[RTE_MAX_LCORE];
+    struct pkt_classifier_engine * pkt_classifier_engine;
 };
 
 static struct node_classifier_main classifier_main = {0};
-struct node_classifier_main * node_classifier_main_get(void)
+static struct classifier_stats stats_per_graph[RTE_MAX_LCORE] = {0};
+
+static inline struct node_classifier_main * node_classifier_main_get(void)
 {
     return &classifier_main;
 }
 
 /* Each ruleset type should implement its own 'rules verify' function to validate its unique match fields. */
-int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_error_reason, unsigned int sz_error_reason)
+static inline int classifier_rules_verify(const struct rule_list_parsed rule_list[])
 {
     for (uint32_t index = 0; index < rule_list->nr_rules; index++)
     {
         /* Verify the adapter ID. */
-        struct rule_field_parser * rule_field_parser = &rule_list->rules[index];
+        const struct rule_field_parser * rule_field_parser = &rule_list->rules[index];
         if (rule_field_parser->adapter.type == ADAPTER_TYPE_EF)
         {
             if (ef_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR)
             {
-                snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.",
-                         rule_field_parser->rule_id, rule_field_parser->adapter.id);
+                MR_ERROR("The rule ID '%u' with configured ef adapter ID '%u' is invalid.", rule_field_parser->rule_id,
+                         rule_field_parser->adapter.id);
                 return RT_ERR;
             }
         }
@@ -65,7 +66,7 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro
         {
             if (vwire_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR)
             {
-                snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.",
+                MR_ERROR("The rule ID '%u' with configured vwire adapter ID '%u' is invalid.",
                          rule_field_parser->rule_id, rule_field_parser->adapter.id);
                 return RT_ERR;
             }
@@ -74,7 +75,7 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro
         {
             if (tera_adapter_id_check(rule_field_parser->adapter.id) == RT_ERR)
             {
-                snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config adapter id '%u' is invalid.",
+                MR_ERROR("The rule ID '%u' with configured tera adapter ID '%u' is invalid.",
                          rule_field_parser->rule_id, rule_field_parser->adapter.id);
                 return RT_ERR;
             }
@@ -86,8 +87,8 @@ int classifier_rules_verify(struct rule_list_parsed * rule_list, char * str_erro
             /* Verify the sid. */
             if (sid_check(rule_field_parser->action.sid) == RT_ERR)
             {
-                snprintf(str_error_reason, sz_error_reason - 1, "The rule id '%u', config action sid '%u' is invalid.",
-                         rule_field_parser->rule_id, rule_field_parser->action.sid);
+                MR_ERROR("The rule ID '%u' with configured action SID '%u' is invalid.", rule_field_parser->rule_id,
+                         rule_field_parser->action.sid);
                 return RT_ERR;
             }
         }
@@ -118,7 +119,8 @@ static inline uint16_t domain_field_generator_for_classifier(enum adapter_type t
     return domain_field;
 }
 
-void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed, struct rule_list_engine * rule_list_engine)
+static inline void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed,
+                                              struct rule_list_engine * rule_list_engine)
 {
     rule_list_engine->nr_rules = rule_list_parsed->nr_rules;
     for (uint32_t index = 0; index < rule_list_parsed->nr_rules; index++)
@@ -163,36 +165,26 @@ void rule_list_engine_generator(struct rule_list_parsed * rule_list_parsed, stru
     }
 }
 
-int classifier_rule_full_update(struct sc_main * sc, cJSON * c_rule, char * str_error_reason,
-                                unsigned int sz_error_reason)
+int classifier_rule_update(struct sc_main * sc)
 {
     /* Parse the local rules. */
     struct node_classifier_main * classifier_main = node_classifier_main_get();
-    pkt_classifier_engine_t * engine_instance = classifier_main->engine_instance;
+    struct pkt_classifier_engine * pkt_classifier_engine = classifier_main->pkt_classifier_engine;
     struct rule_list_parsed rule_list_parsed = {0};
-    int ret = pkt_classifier_local_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(engine_instance),
-                                               &rule_list_parsed);
-    if (ret != RT_SUCCESS)
-    {
-        snprintf(str_error_reason, sz_error_reason - 1, "Pkt classifier rule parse failed for local.");
-        MR_ERROR("Pkt classifier rule parse failed for local.");
-        return RT_ERR;
-    }
 
-    /* Parse the remote rules. */
-    ret = pkt_classifier_remote_rule_parser(c_rule, &rule_list_parsed, str_error_reason, sz_error_reason - 1);
+    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                         &rule_list_parsed);
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Pkt classifier rule parse failed for remote.");
-        MR_ERROR("%s", str_error_reason);
+        MR_ERROR("Parsing of packet classifier rule failed.");
         return RT_ERR;
     }
 
     /* Verify the classifier rule. */
-    ret = classifier_rules_verify(&rule_list_parsed, str_error_reason, sz_error_reason);
+    ret = classifier_rules_verify(&rule_list_parsed);
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Check classifier rules failed, reason:  %s", str_error_reason);
+        MR_ERROR("Check classifier rules failed.");
         return RT_ERR;
     }
 
@@ -201,57 +193,25 @@ int classifier_rule_full_update(struct sc_main * sc, cJSON * c_rule, char * str_
     rule_list_engine_generator(&rule_list_parsed, &rule_list_engine);
 
     /* Construct the packet classifier engine. */
-    ret = pkt_classifier_engine_build(engine_instance, &rule_list_engine, str_error_reason, sz_error_reason);
+    ret = pkt_classifier_engine_build(pkt_classifier_engine, &rule_list_engine);
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Pkt classifier engine build failed, reason:  %s", str_error_reason);
+        MR_ERROR("Pkt classifier engine build failed");
         return RT_ERR;
     }
 
     /* Display information about the packet classifier rules. */
     classifier_rule_dump(&rule_list_parsed);
-    pkt_classifier_engine_info_dump(engine_instance);
+    pkt_classifier_engine_info_dump(pkt_classifier_engine);
 
     return RT_SUCCESS;
 }
 
-static int __classifier_rule_full_update_request_handler(cJSON * req, cJSON ** rsp, void * arg)
-{
-    struct sc_main * sc = (struct sc_main *)arg;
-    char str_error_reason[MR_STRING_MAX] = {};
-    cJSON * response = cJSON_CreateObject();
-
-    int ret = classifier_rule_full_update(sc, req, str_error_reason, sizeof(str_error_reason));
-    if (ret != RT_SUCCESS)
-    {
-        cJSON_AddNumberToObject(response, "Result", RT_ERR);
-        cJSON_AddStringToObject(response, "Reason", str_error_reason);
-        *rsp = response;
-        return 0;
-    }
-    else
-    {
-        cJSON_AddNumberToObject(response, "Result", RT_SUCCESS);
-    }
-
-    *rsp = response;
-    return 0;
-}
-
 int classifier_init(struct sc_main * sc)
 {
     /* Initialize the main instance of the classifier. */
     struct node_classifier_main * classifier_main = node_classifier_main_get();
     memset(classifier_main, 0, sizeof(struct node_classifier_main));
-    sc->node_classifier_main = classifier_main;
-
-    /* Register the handler for full classifier rule updates. */
-    if (rpc_server_recv_request_register(sc->rpc_srv_handler, PKT_CLASSIFIER_RULE_FULL_UPDATE,
-                                         __classifier_rule_full_update_request_handler, sc) != 0)
-    {
-        MR_ERROR("The '%s' Request Register Failed. ", PKT_CLASSIFIER_RULE_FULL_UPDATE);
-        return RT_ERR;
-    }
 
     /* Load to ignore icmp and icmpv6 options */
     MESA_load_profile_uint_def(sc->local_cfgfile, "classifiers", "ignore_all_icmp_pkts",
@@ -263,36 +223,41 @@ int classifier_init(struct sc_main * sc)
     classifier_main->nr_ef_adapters = nr_ef_adapters_get();
     classifier_main->nr_vwire_adapters = nr_vwire_adapters_get();
     classifier_main->nr_tera_adapters = nr_tera_adapters_get();
-    uint16_t nr_domains =
-        classifier_main->nr_ef_adapters + classifier_main->nr_vwire_adapters + classifier_main->nr_tera_adapters;
-    pkt_classifier_engine_t * engine_instance =
+
+    uint16_t nr_domains = classifier_main->nr_ef_adapters;
+    nr_domains += classifier_main->nr_vwire_adapters;
+    nr_domains += +classifier_main->nr_tera_adapters;
+
+    /* Create pkt classifier engine */
+    struct pkt_classifier_engine * pkt_classifier_engine =
         pkt_classifier_engine_create(sc->nr_io_thread, &sc->cpu_set_io, nr_domains, RULESET_TYPE_CLASSIFIER);
-    if (engine_instance == NULL)
+
+    if (pkt_classifier_engine == NULL)
     {
         MR_ERROR("Failed to create the packet classifier engine for the classifier node.");
         return RT_ERR;
     }
     else
     {
-        classifier_main->engine_instance = engine_instance;
+        classifier_main->pkt_classifier_engine = pkt_classifier_engine;
     }
 
-    /* Parse the local rules. */
+    /* Parse the rules. */
     struct rule_list_parsed rule_list_parsed = {0};
-    int ret = pkt_classifier_local_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(engine_instance),
-                                               &rule_list_parsed);
+    int ret = pkt_classifier_rule_parser(sc, pkt_classifier_engine_get_ruleset_type(pkt_classifier_engine),
+                                         &rule_list_parsed);
+
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Pkt classifier rule parse failed for local.");
+        MR_ERROR("Parsing of packet classifier rule failed.");
         return RT_ERR;
     }
 
     /* Verify the classifier rule. */
-    char str_error_reason[MR_STRING_MAX];
-    ret = classifier_rules_verify(&rule_list_parsed, str_error_reason, sizeof(str_error_reason));
+    ret = classifier_rules_verify(&rule_list_parsed);
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Check classifier rules failed, reason:  %s", str_error_reason);
+        MR_ERROR("Check classifier rules failed.");
         return RT_ERR;
     }
 
@@ -301,16 +266,16 @@ int classifier_init(struct sc_main * sc)
     rule_list_engine_generator(&rule_list_parsed, &rule_list_engine);
 
     /* Construct the packet classifier engine. */
-    ret = pkt_classifier_engine_build(engine_instance, &rule_list_engine, str_error_reason, sizeof(str_error_reason));
+    ret = pkt_classifier_engine_build(pkt_classifier_engine, &rule_list_engine);
     if (ret != RT_SUCCESS)
     {
-        MR_ERROR("Pkt classifier engine build failed, reason:  %s", str_error_reason);
+        MR_ERROR("Pkt classifier engine build failed");
         return RT_ERR;
     }
 
     /* Display information about the packet classifier rules. */
     classifier_rule_dump(&rule_list_parsed);
-    pkt_classifier_engine_info_dump(engine_instance);
+    pkt_classifier_engine_info_dump(pkt_classifier_engine);
     return RT_SUCCESS;
 }
 
@@ -319,7 +284,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
                                                             void ** objs, uint16_t cnt)
 {
     struct node_classifier_main * classifier_main = node_classifier_main_get();
-    pkt_classifier_engine_t * engine_instance = classifier_main->engine_instance;
+    struct pkt_classifier_engine * pkt_classifier_engine = classifier_main->pkt_classifier_engine;
     unsigned int ignore_all_icmp_pkts = classifier_main->ignore_all_icmp_pkts;
     unsigned int ignore_all_icmp6_pkts = classifier_main->ignore_all_icmp6_pkts;
 
@@ -348,8 +313,8 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         }
 
         struct match_result_engine result[FWDSTEP];
-        pkt_classifier_engine_multi_match(engine_instance, lcore_id, pending_mbufs, FWDSTEP, domain_field_for_pkts,
-                                          result);
+        pkt_classifier_engine_multi_match(pkt_classifier_engine, lcore_id, pending_mbufs, FWDSTEP,
+                                          domain_field_for_pkts, result);
 
         /* All the ICMP packet, go direct to egress, not for nfs */
         if (ignore_all_icmp_pkts)
@@ -426,7 +391,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         struct mrb_metadata * mrb_metadata = mrbuf_cz_data(mbuf0, MR_NODE_CTRLZONE_ID);
         uint16_t pattern_group_id =
             domain_field_generator_for_classifier(mrb_metadata->adapter_type, mrb_metadata->adapter_id);
-        pkt_classifier_engine_multi_match(engine_instance, lcore_id, &mbuf0, 1, &pattern_group_id, &result);
+        pkt_classifier_engine_multi_match(pkt_classifier_engine, lcore_id, &mbuf0, 1, &pattern_group_id, &result);
 
         /* All the ICMP packet, go direct to egress, not for nfs */
         if (ignore_all_icmp_pkts)
@@ -486,7 +451,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
     rte_node_next_stream_move(graph, node, CLASSIFIER_NEXT_FORWARDER);
 
     /* Update the graph statistics */
-    struct classifier_stats * graph_stats = &classifier_main->stats_per_graph[graph->id];
+    struct classifier_stats * graph_stats = &stats_per_graph[graph->id];
     graph_stats->deal_pkts += cnt;
     graph_stats->hits += stats.hits;
     graph_stats->miss += stats.miss;
@@ -511,11 +476,10 @@ cJSON * classifier_node_monit_loop(struct sc_main * sc)
 {
     cJSON * json_root = cJSON_CreateObject();
     unsigned int nr_graph_total = sc->nr_io_thread;
-    struct node_classifier_main * classifier_main = sc->node_classifier_main;
 
     for (uint32_t graph_id = 0; graph_id < nr_graph_total; graph_id++)
     {
-        struct classifier_stats * graph_stats = &classifier_main->stats_per_graph[graph_id];
+        struct classifier_stats * graph_stats = &stats_per_graph[graph_id];
         if (graph_stats->deal_pkts == 0)
             continue;