✨ feat(TSG-11498): Acl适配Rpc框架

Acl适配Rpc框架

1 files changed, 130 insertions, 109 deletions

diff --git a/tools/acl_rule_test/acl_rule_test.c b/tools/acl_rule_test/acl_rule_test.c
index bed7c2d..513d9da 100644
--- a/tools/acl_rule_test/acl_rule_test.c
+++ b/tools/acl_rule_test/acl_rule_test.c
@@ -13,6 +13,7 @@
 #include <rte_flow.h>
 #include <sc_flow.h>
 #include <rte_version.h>
+#include <rpc.h>
 
 #define GLOBAL_CONF_FILE_PATH                       "/opt/tsg/mrzcpd/etc/mrglobal.conf"
 #define MR_CLI_ARG_LIST                             "hcsdg:iep:"
@@ -20,14 +21,18 @@
 #define MR_CLI_RESPONSE_ENABLE                      1
 #define MR_CLI_CLOSE_DELAY                          100
 
-/* Rule Flag */
-enum mr_cli_rule_flag
-{
-    MR_RULE_TYPE_ENABLE = 1 << 0,
-    MR_RULE_ITEM_ENABLE = 1 << 1,
-    MR_RULE_ACTION_ENABLE = 1 << 2,
-    MR_RULE_VALID = (MR_RULE_TYPE_ENABLE | MR_RULE_ITEM_ENABLE | MR_RULE_ACTION_ENABLE),
-};
+/* Dynamic Acl Rule Topic */
+#ifndef MR_ACL_TOPIC_IPV4_SINGLE_RULE_ADD
+#define MR_ACL_TOPIC_IPV4_SINGLE_RULE_ADD                       "IPv4SingleRuleAdd"
+#endif
+
+#ifndef MR_ACL_TOPIC_IPV4_SINGLE_RULE_DEL
+#define MR_ACL_TOPIC_IPV4_SINGLE_RULE_DEL                       "IPv4SingleRuleDel"
+#endif
+
+#ifndef MR_ACL_RPC_RESULT
+#define MR_ACL_RPC_RESULT                                       "Result"
+#endif
 
 enum mr_cli_arg
 {
@@ -38,17 +43,14 @@ enum mr_cli_arg
     MR_CLI_REPEATED,
 };
 /* Instance */
-struct mrctl_instance
+struct rpc_instance
 {
     volatile unsigned  response_flag;
-    struct ctrlmsg_handler * ctrlmsg_handler;
+    struct rpc_client_handler * handler;
 };
 
 /* The Global ariable */
-struct mrctl_instance * mrctl_instance = NULL;
-unsigned int g_logger_to_stdout = 1;
-unsigned int g_logger_level = LOG_DEBUG;
-struct mrctl_flow_rule * rule_global;
+struct rpc_instance * rpc_instance = NULL;
 
 /* Command Line Options */
 static struct option cli_options[] =
@@ -63,13 +65,19 @@ static struct option cli_options[] =
     {"repeated", no_argument,NULL, MR_CLI_REPEATED},
 };
 
-
-/* Mrctl Create */
-struct mrctl_instance * mrctl_create()
+/* Rpc Create */
+struct rpc_instance * rpc_create()
 {
-    struct mrctl_instance * instance;
-    instance = malloc(sizeof(struct mrctl_instance));
-    memset(instance, 0, sizeof(struct mrctl_instance));
+    struct rpc_instance * instance;
+    instance = malloc(sizeof(struct rpc_instance));
+    memset(instance, 0, sizeof(struct rpc_instance));
+
+    instance->handler = rpc_client_alloc_handler(RPC_CLIENT_MODE_ASYNC);
+    if(instance->handler == NULL)
+    {
+        printf("Alloc client handler failed\n");
+        return NULL;
+    }
 
     instance->response_flag = MR_CLI_RESPONSE_DISABLE;
 
@@ -78,54 +86,48 @@ struct mrctl_instance * mrctl_create()
 
 void help()
 {
-    printf("--add + (rule num)           eg: --a 1024}\n");
-    printf("--delete_all                 eg: --delete_all}\n");
+    printf("--add + (rule num)        eg: --a 1024}\n");
+    printf("--delete_all              eg: --delete_all}\n");
     printf("--add_id + (rule id)      eg: --add_id 33 }\n");
     printf("--delete_id + (rule id)   eg: --add_id 33 }\n");
+    printf("--loop                    eg: --loop }\n");
+    printf("--repeated                eg: --repeated }\n");
 }
-/* Ctrlmsg Init */
-static int mrctl_ctrlmsg_init(struct mrctl_instance * instance)
+
+/* Rpc Init */
+static int rpc_init(struct rpc_instance * instance)
 {
-    char str_ctrlmsg_addr[MR_STRING_MAX] = { 0 };
-    unsigned int ctrlmsg_port = 0;
-    unsigned int loglevel = g_logger_level + 1;
+    char str_rpc_addr[MR_STRING_MAX] = { 0 };
+    unsigned int rpc_port = 0;
 
     /* Get Ip & Port */
-    MESA_load_profile_string_def(GLOBAL_CONF_FILE_PATH, "ctrlmsg", "listen_addr", str_ctrlmsg_addr, sizeof(str_ctrlmsg_addr), CTRLMSG_DEFAULT_ADDR);
-    MESA_load_profile_uint_def(GLOBAL_CONF_FILE_PATH, "ctrlmsg", "listen_port", &ctrlmsg_port, CTRLMSG_DEFAULT_PORT);
-    MESA_load_profile_uint_def(GLOBAL_CONF_FILE_PATH, "eal", "loglevel", &loglevel, loglevel);
-    g_logger_level = loglevel - 1;
+    MESA_load_profile_string_def(GLOBAL_CONF_FILE_PATH, "ctrlmsg", "listen_addr", str_rpc_addr, sizeof(str_rpc_addr), CTRLMSG_DEFAULT_ADDR);
+    MESA_load_profile_uint_def(GLOBAL_CONF_FILE_PATH, "ctrlmsg", "listen_port", &rpc_port, CTRLMSG_DEFAULT_PORT);
 
     /* Change Ip Addr */
     struct sockaddr_in sockaddr_in;
-    if (inet_pton(AF_INET, str_ctrlmsg_addr, &sockaddr_in.sin_addr) <= 0)
+    if (inet_pton(AF_INET, str_rpc_addr, &sockaddr_in.sin_addr) <= 0)
     {
-        MR_CFGERR_INVALID_FORMAT(GLOBAL_CONF_FILE_PATH, "ctrlmsg", "listen_addr");
         return RT_ERR;
     }
 
     /* Set Port */
-    sockaddr_in.sin_port = htons(ctrlmsg_port);
+    sockaddr_in.sin_port = htons(rpc_port);
     sockaddr_in.sin_family = AF_INET;
 
     /* Creat Msg Handler */
-    instance->ctrlmsg_handler = ctrlmsg_handler_create(CTRLMSG_HANDLER_MODE_CLIENT, sockaddr_in, NULL, -1);
-    if (instance->ctrlmsg_handler == NULL) return RT_ERR;
+    if(rpc_client_connect(instance->handler, sockaddr_in) != 0)
+    {
+        printf("Client Connect Server Failed !!!\n");
+        return RT_ERR;
+    }
     return RT_SUCCESS;
 }
 
-static int __conn_close_handler(struct ctrlmsg_handler * ct_hand,
-    struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
-{
-    MR_INFO("Ctrlplane connection is terminated, Exit. ");
-    exit(EXIT_FAILURE);
-}
-
-void send_acl_rule_add_msg(struct mrctl_instance * instance,int rule_id)
+void send_acl_rule_add_msg(struct rpc_instance * instance,int rule_id)
 {
 
     cJSON *cjson_rule = NULL;
-    struct ctrl_msg_flow_request req_msg;
     char str_src_addr[MR_STRING_MAX] = { 0 };
     char str_dst_addr[MR_STRING_MAX] = { 0 };
 
@@ -140,10 +142,6 @@ void send_acl_rule_add_msg(struct mrctl_instance * instance,int rule_id)
         sprintf(str_dst_addr, "%s", "192.168.102.1");
     }
 
-
-    memset(&req_msg, 0, sizeof(req_msg));
-    ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_ACL4_ADD);
-
     cjson_rule = cJSON_CreateObject();
     cJSON_AddNumberToObject(cjson_rule, "RuleType", 4);
     cJSON_AddNumberToObject(cjson_rule, "RuleId", rule_id);
@@ -161,22 +159,21 @@ void send_acl_rule_add_msg(struct mrctl_instance * instance,int rule_id)
     cJSON_AddStringToObject(cjson_rule, "Action", "nf_steering");
     cJSON_AddNumberToObject(cjson_rule, "NextGroup", rule_id%2);
 
-    char * str_rule = cJSON_Print(cjson_rule);
-    snprintf((char *)req_msg.cmd, sizeof(req_msg.cmd), "%s", str_rule);
-    /* send req */
-    ctrlmsg_msg_send(instance->ctrlmsg_handler, NULL, (struct ctrl_msg_header*)&req_msg);
-    /* Set Creat Response Disable */
-    __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_DISABLE, __ATOMIC_SEQ_CST);
+    if(rpc_client_send_request_async(instance->handler, MR_ACL_TOPIC_IPV4_SINGLE_RULE_ADD, cjson_rule) != 0)
+    {
+        printf("Send Add Request Failed !!!\n");
+    }
+    else
+    {
+        /* Set Creat Response Disable */
+        __atomic_exchange_n(&instance->response_flag, MR_CLI_RESPONSE_DISABLE, __ATOMIC_SEQ_CST);
+    }
+    cJSON_Delete(cjson_rule);
 }
 
-void send_acl_rule_del_msg(struct mrctl_instance * instance,int rule_id)
+void send_acl_rule_del_msg(struct rpc_instance * instance,int rule_id)
 {
-
     cJSON *cjson_rule = NULL;
-    struct ctrl_msg_flow_request req_msg;
-
-    memset(&req_msg, 0, sizeof(req_msg));
-    ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_ACL4_DELETE);
 
     cjson_rule = cJSON_CreateObject();
 
@@ -196,51 +193,73 @@ void send_acl_rule_del_msg(struct mrctl_instance * instance,int rule_id)
     cJSON_AddStringToObject(cjson_rule, "Action", "nf_steering");
     cJSON_AddNumberToObject(cjson_rule, "NextGroup", rule_id%2);
 
-    char * str_rule = cJSON_Print(cjson_rule);
-    snprintf((char *)req_msg.cmd, sizeof(req_msg.cmd), "%s", str_rule);
-    /* send req */
-    ctrlmsg_msg_send(instance->ctrlmsg_handler, NULL, (struct ctrl_msg_header*)&req_msg);
-    /* Set Creat Response Disable */
-    __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_DISABLE, __ATOMIC_SEQ_CST);
+    if(rpc_client_send_request_async(instance->handler, MR_ACL_TOPIC_IPV4_SINGLE_RULE_DEL, cjson_rule) != 0)
+    {
+        printf("Send Del Request Failed !!!\n");
+    }
+    else
+    {
+        /* Set Creat Response Disable */
+        __atomic_exchange_n(&instance->response_flag, MR_CLI_RESPONSE_DISABLE, __ATOMIC_SEQ_CST);
+    }
+    cJSON_Delete(cjson_rule);
 }
 
 /* Rual Add Response */
-static int __rule_add_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
+static int __rule_add_response_handler(cJSON *rsp, void *arg)
 {
-    struct ctrl_msg_flow_response * rep_msg = (struct ctrl_msg_flow_response *)msg;
-    struct mrctl_instance * mrctl_instance = (struct mrctl_instance *)arg;
+    cJSON * j_result = NULL;
+    struct rpc_instance * rpc_instance = (struct rpc_instance *)arg;
+
+    j_result = cJSON_GetObjectItem(rsp,MR_ACL_RPC_RESULT);
 
-    if (rep_msg->msg_err.errcode == RT_SUCCESS)
+    if (j_result == NULL)
     {
-        printf("The One Acl Rule Add Sucess.\n");
+        printf("The Result Is Null !\n");
     }
     else
     {
-        printf("One Acl Rule Add Error. Error Code:%d\n",rep_msg->msg_err.errcode);
+        if ((u_int32_t)j_result->valuedouble == RT_SUCCESS)
+        {
+            printf("The One Acl Rule Add Sucess.\n");
+        }
+        else
+        {
+            printf("One Acl Rule Add Error. Error Code:%u\n",(u_int32_t)j_result->valuedouble);
+        }
     }
 
     /* Set Creat Response Enable */
-    __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
+    __atomic_exchange_n(&rpc_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
     return RT_SUCCESS;
 }
 
 /* Rual Delete Response */
-static int __rule_del_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
+static int __rule_del_response_handler(cJSON *rsp, void *arg)
 {
-    struct ctrl_msg_flow_response * rep_msg = (struct ctrl_msg_flow_response *)msg;
-    struct mrctl_instance * mrctl_instance = (struct mrctl_instance *)arg;
+    cJSON * j_result = NULL;
+    struct rpc_instance * rpc_instance = (struct rpc_instance *)arg;
+
+    j_result = cJSON_GetObjectItem(rsp,MR_ACL_RPC_RESULT);
 
-    if (rep_msg->msg_err.errcode == RT_SUCCESS)
+    if (j_result == NULL)
     {
-        printf("The One Acl Rule Delete Sucess.\n");
+        printf("The Result Is Null !\n");
     }
     else
     {
-        printf("One Acl Rule Delete Error. Error Code:%d\n",rep_msg->msg_err.errcode);
+        if ((u_int32_t)j_result->valuedouble == RT_SUCCESS)
+        {
+            printf("The One Acl Rule Del Sucess.\n");
+        }
+        else
+        {
+            printf("One Acl Rule Del Error. Error Code:%d\n",(u_int32_t)j_result->valuedouble);
+        }
     }
 
     /* Set Creat Response Enable */
-    __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
+    __atomic_exchange_n(&rpc_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
     return RT_SUCCESS;
 }
 
@@ -303,31 +322,34 @@ int main(int argc, char * argv[])
     }
 
     /* Create instance */
-    mrctl_instance = mrctl_create();
-    if (mrctl_instance == NULL)
+    rpc_instance = rpc_create();
+    if (rpc_instance == NULL)
     {
         fprintf(stderr, "Acl Rult Test instance create failed. ");
         return 0;
     }
 
-    if (mrctl_ctrlmsg_init(mrctl_instance) != RT_SUCCESS)
+    if(rpc_client_recv_response_register(rpc_instance->handler, MR_ACL_TOPIC_IPV4_SINGLE_RULE_ADD, __rule_add_response_handler , rpc_instance) != 0)
     {
-        fprintf(stderr, "Ctrlmsg module initialization failed. ");
+        printf("Register Add Response Callback Failed !!!\n");
         return 0;
     }
 
-    /* Add Response */
-    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_ACL4_ADD,CTRL_MSG_TYPE_RESPONSE, __rule_add_response_handler, mrctl_instance);
-    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_ACL4_DELETE,CTRL_MSG_TYPE_RESPONSE, __rule_del_response_handler, mrctl_instance);
-
-    /* Conn Close */
-    ctrlmsg_event_conn_close_register(mrctl_instance->ctrlmsg_handler,__conn_close_handler, mrctl_instance);
+    if(rpc_client_recv_response_register(rpc_instance->handler, MR_ACL_TOPIC_IPV4_SINGLE_RULE_DEL, __rule_del_response_handler , rpc_instance) != 0)
+    {
+        printf("Register Del Response Callback Failed !!!\n");
+        return 0;
+    }
 
+    if (rpc_init(rpc_instance) != RT_SUCCESS)
+    {
+        fprintf(stderr, "Rpc module initialization failed. ");
+        return 0;
+    }
 
-    /* Create Ctrlmsg Thread */
-    if (ctrlmsg_thread_launch(mrctl_instance->ctrlmsg_handler) != RT_SUCCESS)
+    if(rpc_client_dispatch_thread(rpc_instance->handler) != 0)
     {
-        fprintf(stderr, "Launch ctrlmsg thread failed. ");
+        printf("Client Start Dispach Thread Failed !!!\n");
         return 0;
     }
 
@@ -337,9 +359,9 @@ int main(int argc, char * argv[])
         /* Send Create Requeset Msg */
         for (int i = 1; i <= deal_num; i ++)
         {
-            send_acl_rule_add_msg(mrctl_instance,i);
+            send_acl_rule_add_msg(rpc_instance,i);
             printf("Send Add:%d\n",i);
-            while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+            while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
             {
                 usleep(1);
             }
@@ -349,9 +371,9 @@ int main(int argc, char * argv[])
     {
         for (int i = deal_num; i > 0; i --)
         {
-            send_acl_rule_del_msg(mrctl_instance,i);
+            send_acl_rule_del_msg(rpc_instance,i);
             printf("Send Delete:%d\n",i);
-            while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+            while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
             {
                 usleep(1);
             }
@@ -359,18 +381,18 @@ int main(int argc, char * argv[])
     }
     else if (type == 3)
     {
-        send_acl_rule_add_msg(mrctl_instance,deal_num);
+        send_acl_rule_add_msg(rpc_instance,deal_num);
         printf("Send Add:%d\n",deal_num);
-        while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+        while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
         {
             usleep(1);
         }
     }
     else if (type == 4)
     {
-        send_acl_rule_del_msg(mrctl_instance,deal_num);
+        send_acl_rule_del_msg(rpc_instance,deal_num);
         printf("Send Delete:%d\n",deal_num);
-        while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+        while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
         {
             usleep(1);
         }
@@ -382,9 +404,9 @@ int main(int argc, char * argv[])
             /* Send Create Requeset Msg */
             for (int i = 1; i <= 1024; i ++)
             {
-                send_acl_rule_add_msg(mrctl_instance,i);
+                send_acl_rule_add_msg(rpc_instance,i);
                 printf("Send Add:%d\n",i);
-                while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+                while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
                 {
                     usleep(1);
                 }
@@ -392,9 +414,9 @@ int main(int argc, char * argv[])
 
             for (int i = 1024; i > 0; i --)
             {
-                send_acl_rule_del_msg(mrctl_instance,i);
+                send_acl_rule_del_msg(rpc_instance,i);
                 printf("Send Delete:%d\n",i);
-                while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+                while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
                 {
                     usleep(1);
                 }
@@ -406,9 +428,9 @@ int main(int argc, char * argv[])
         /* Send Create Requeset Msg */
         for (int i = 1; i <= 2; i ++)
         {
-            send_acl_rule_add_msg(mrctl_instance,1);
+            send_acl_rule_add_msg(rpc_instance,1);
             printf("Send Add:%d\n",i);
-            while (__atomic_load_n(&mrctl_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
+            while (__atomic_load_n(&rpc_instance->response_flag, __ATOMIC_RELAXED) == MR_CLI_RESPONSE_DISABLE)
             {
                 usleep(1);
             }
@@ -420,6 +442,5 @@ int main(int argc, char * argv[])
         help();
     }
 
-
     return RT_SUCCESS;
 }
\ No newline at end of file