✨ feat(TSG-10357): 添加获取FlowRuleCount功能

添加获取FlowRuleCount功能

TSG-10357

1 files changed, 168 insertions, 0 deletions

diff --git a/tools/mrctl/mrctl.c b/tools/mrctl/mrctl.c
index a2f6965..4d07df0 100644
--- a/tools/mrctl/mrctl.c
+++ b/tools/mrctl/mrctl.c
@@ -19,12 +19,18 @@
 #define MR_CLI_RESPONSE_ENABLE                      1
 #define MR_CLI_CLOSE_DELAY                          100
 
+
+struct mrctl_flow_rule * rule_global;
+
 /* Cli Arg List */
 enum mr_cli_arg
 {
     MR_CLI_ATTR_PRIORITY = 1000,
     MR_CLI_DELETE_RULE_ID,
     MR_CLI_DELETE_ALL,
+    MR_CLI_GET_COUNT,
+    MR_CLI_COUNT_RULE_ID,
+    MR_CLI_COUNT_ALL,
     MR_CLI_ITEM_ETHER,
     MR_CLI_ITEM_ETHER_SMAC,
     MR_CLI_ITEM_ETHER_DMAC,
@@ -97,6 +103,9 @@ static struct option cli_options[] =
     {"rule_id", required_argument,NULL, MR_CLI_DELETE_RULE_ID},
     {"all", no_argument,NULL, MR_CLI_DELETE_ALL},
     {"search", no_argument,NULL, 's'},
+    {"get_count", no_argument,NULL, MR_CLI_GET_COUNT},
+    {"count_rule_id", required_argument,NULL, MR_CLI_COUNT_RULE_ID},
+    {"count_all", no_argument,NULL, MR_CLI_COUNT_ALL},
     {"ingress", no_argument,NULL, 'i'},
     {"egress", no_argument,NULL, 'e'},
     {"portname", required_argument,NULL, 'p'},
@@ -289,6 +298,14 @@ int rule_check(struct mrctl_flow_rule * rule_item)
             return RT_ERR;
         }
     }
+    else if (rule_item->rule_type == MR_RULE_GET_RULE_COUNT)
+    {
+        if (rule_item->get_count.arg_flag == MR_RULE_FLOW_GET_RULE_COUNT_ARG_NOT_SET )
+        {
+            printf("ERROR : Set At Least One Get Count Arg \n");
+            return RT_ERR;
+        }
+    }
     return RT_SUCCESS;
 }
 
@@ -801,6 +818,7 @@ static int __flow_search_response_handler(struct ctrlmsg_handler * ct_hand, stru
     }
     return RT_SUCCESS;
 }
+
 /* Flow Delete Response */
 static int __flow_delete_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
 {
@@ -833,6 +851,93 @@ static int __flow_delete_response_handler(struct ctrlmsg_handler * ct_hand, stru
     return RT_SUCCESS;
 }
 
+/* Flow Get Count Response */
+static int __flow_get_count_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
+{
+    cJSON * cjson_count_response = NULL;
+    struct ctrl_msg_flow_response * rep_msg = (struct ctrl_msg_flow_response *)msg;
+    struct mrctl_instance * mrctl_instance = (struct mrctl_instance *)arg;
+
+    if (rep_msg->msg_err.errcode == RT_SUCCESS)
+    {
+        /* Parsing Count Json Str */
+        cjson_count_response = cJSON_Parse((char *)rep_msg->msg_err.strerr);
+        if (cjson_count_response == NULL)
+        {
+            printf("Cant Parsing The Get Count Success Json Str.\n");
+            return RT_ERR;
+        }
+
+        /* Parsing Success Info Str */
+        cJSON * cjson_count_success = cJSON_GetObjectItem(cjson_count_response,MR_CJSON_KEY_SUCCESS_INFO);
+        if (cjson_count_success == NULL)
+        {
+            printf("Cant Get The Get Count Success Info.\n");
+            return RT_ERR;
+        }
+
+        /* Parsing Success Info */
+        cJSON * cjson_count_success_info = cJSON_Parse((char *)cjson_count_success->valuestring);
+        if (cjson_count_success_info == NULL)
+        {
+            printf("Cant Parsing The Get Count Success Info.\n");
+            return RT_ERR;
+        }
+
+        /* Parsing Count */
+        cJSON * cj_count = cJSON_GetObjectItem(cjson_count_success_info,MR_CJSON_KEY_COUNT);
+        if (cj_count != NULL)
+        {
+            /* Parsing RuleId */
+            cJSON * cj_rule_id = cJSON_GetObjectItem(cj_count,MR_CJSON_KEY_COUNT_RULE_ID);
+            if (cj_rule_id != NULL)
+            {
+                 printf("RuleId: %u",(u_int32_t)cj_rule_id->valuedouble);
+            }
+
+            /* Parsing Hits */
+            cJSON * cj_hits = cJSON_GetObjectItem(cj_count,MR_CJSON_KEY_COUNT_HITS);
+            if (cj_hits != NULL)
+            {
+                 printf("    Hits: %lu",(uint64_t)cj_hits->valuedouble);
+            }
+            printf("\n");
+        }
+
+        /* Parsing End */
+        cJSON * cj_count_end = cJSON_GetObjectItem(cjson_count_success_info,MR_CJSON_KEY_RULE_END);
+        if (cj_count_end != NULL)
+        {
+            /* Set Creat Response Enable */
+            __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
+        }
+    }
+    else
+    {
+        printf("The Get Flow Rule Count Error.\n");
+        printf("%s\n",(char *)rep_msg->msg_err.strerr);
+        cjson_count_response = cJSON_Parse((char *)rep_msg->msg_err.strerr);
+        if (cjson_count_response == NULL)
+        {
+            printf("Cant Parsing The Get Count Error Json Str.\n");
+            return RT_ERR;
+        }
+        cJSON * cj_error_info = cJSON_GetObjectItem(cjson_count_response,MR_CJSON_KEY_ERROR_INFO);
+        if (cj_error_info == NULL)
+        {
+            printf("Cant Parsing The Error Info From Json.\n");
+            return RT_ERR;
+        }
+        printf("Reason : %s\n",cj_error_info->valuestring);
+        if (rule_global->get_count.arg_flag & MR_RULE_FLOW_GET_RULE_COUNT_ARG_RULE_ID)
+        {
+            /* Set Creat Response Enable */
+            __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_ENABLE, __ATOMIC_SEQ_CST);
+        }
+    }
+    return RT_SUCCESS;
+}
+
 /* Send Create Request Msg */
 int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_flow_rule * rule_item)
 {
@@ -1199,6 +1304,35 @@ int send_delete_request_msg(struct mrctl_instance * instance, struct mrctl_flow_
     return RT_SUCCESS;
 }
 
+/* Send Get Rule Count Request Msg */
+int send_get_count_request_msg(struct mrctl_instance * instance, struct mrctl_flow_rule * rule_item)
+{
+    cJSON *cjson_rule = NULL,* get_count_rule = NULL;
+    struct ctrl_msg_flow_request req_msg;
+
+    cjson_rule = cJSON_CreateObject();
+    get_count_rule = cJSON_CreateObject();
+
+    memset(&req_msg, 0, sizeof(req_msg));
+    ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_FLOW_GET_COUNT);
+
+    cJSON_AddNumberToObject(get_count_rule, MR_CJSON_KEY_ARG_FLAG, rule_item->get_count.arg_flag);
+    if (rule_item->get_count.arg_flag & MR_RULE_FLOW_GET_RULE_COUNT_ARG_RULE_ID)
+    {
+        cJSON_AddNumberToObject(get_count_rule, MR_CJSON_KEY_GET_RULE_COUNT_ID, rule_item->get_count.rule_id);
+    }
+
+    cJSON_AddItemToObject(cjson_rule,MR_CJSON_KEY_GET_RULE_COUNT_RULE,get_count_rule);
+
+    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 Response Disable */
+    __atomic_exchange_n(&mrctl_instance->response_flag, MR_CLI_RESPONSE_DISABLE, __ATOMIC_SEQ_CST);
+    return RT_SUCCESS;
+}
+
 /* Help Info */
 int help()
 {
@@ -1209,6 +1343,8 @@ int help()
     printf("    RuleType        : -c,--create           eg: -c\n");
     printf("                      -d,--delete           eg: -c\n");
     printf("                      -s,--search           eg: -c\n");
+    printf("                      --get_count           eg: --get_count\n");
+    printf("  Create Must Choose:\n");
     printf("    Direction       : -i,--ingress          eg: -i\n");
     printf("                      -e,--egress           eg: -e\n");
     printf("    Portname        : -p,--portname         eg: -p ens18f1\n");
@@ -1216,12 +1352,19 @@ int help()
     printf("    Group           : -g,--group            eg: -g 1 \n");
     printf("    Priority        : --priority            eg: --priority 1\n");
     printf("\n");
+
     /* Delete */
     printf("Delete Arg:\n");
     printf("  Must Choose:\n");
     printf("    RuleId          : --rule_id             eg: --rule_id 0\n");
     printf("                      --all                 eg: --all\n");
 
+    /* Get Rule Count */
+    printf("Get Rule Count:\n");
+    printf("  Must Choose:\n");
+    printf("    CountRuleId     : --count_rule_id             eg: --count_rule_id 0\n");
+    printf("                      --count_all                 eg: --count_all 0\n");
+
     /* Items */
     printf("Items:    Must Choose One Item\n");
     printf("  Ether             : --ether               eg: --ether\n");
@@ -1310,6 +1453,7 @@ int main(int argc, char * argv[])
     struct mr_flow_action_set_mac * set_src_mac_action = NULL, * set_dst_mac_action = NULL;
 
     memset(&rule_item, 0, sizeof(rule_item));
+    rule_global = &rule_item;
 
     ether_item = &rule_item.items[MR_RULE_FLOW_ITEM_ETHER].ether_item;
     ipv4_item = &rule_item.items[MR_RULE_FLOW_ITEM_IPV4].ipv4_item;
@@ -1358,6 +1502,23 @@ int main(int argc, char * argv[])
                 rule_item.delete.arg_flag = MR_RULE_FLOW_DELETE_ARG_DELETE_ALL;
                 break;
             }
+            case MR_CLI_GET_COUNT:
+            {
+                rule_item.rule_flag |= MR_RULE_TYPE_ENABLE;
+                rule_item.rule_type = MR_RULE_GET_RULE_COUNT;
+                break;
+            }
+            case MR_CLI_COUNT_RULE_ID:
+            {
+                rule_item.get_count.arg_flag = MR_RULE_FLOW_GET_RULE_COUNT_ARG_RULE_ID;
+                rule_item.get_count.rule_id = (uint8_t)strtoull(optarg, &endptr, 0);
+                break;
+            }
+            case MR_CLI_COUNT_ALL:
+            {
+                rule_item.get_count.arg_flag = MR_RULE_FLOW_GET_RULE_COUNT_ARG_ALL;
+                break;
+            }
             case 's':
             {
                 rule_item.rule_flag |= MR_RULE_TYPE_ENABLE;
@@ -1827,6 +1988,8 @@ int main(int argc, char * argv[])
     ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_FLOW_SEARCH,CTRL_MSG_TYPE_RESPONSE, __flow_search_response_handler, mrctl_instance);
     /* Flow Delete Response */
     ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_FLOW_DELETE,CTRL_MSG_TYPE_RESPONSE, __flow_delete_response_handler, mrctl_instance);
+    /* Flow Get Count Response */
+    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_FLOW_GET_COUNT,CTRL_MSG_TYPE_RESPONSE, __flow_get_count_response_handler, mrctl_instance);
 
     /* Conn Close */
     ctrlmsg_event_conn_close_register(mrctl_instance->ctrlmsg_handler,__conn_close_handler, mrctl_instance);
@@ -1859,6 +2022,11 @@ int main(int argc, char * argv[])
         /* Send Delete Requeset Msg */
         send_delete_request_msg(mrctl_instance,&rule_item);
     }
+    else if (rule_item.rule_type == MR_RULE_GET_RULE_COUNT)
+    {
+        /* code */
+        send_get_count_request_msg(mrctl_instance,&rule_item);
+    }
 
     while (1)
     {