Merge pull request #2519 from fengzeroz/v2.11

version: 2.11.4

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
       - published
 
 env:
-  VERSION: 2.11.3
+  VERSION: 2.11.4
   UI_VERSION: 2.6.1
   BRANCH: v2.11
 

include/neuron/define.h

@@ -24,7 +24,7 @@
 
 #define NEU_VERSION_MAJOR 2
 #define NEU_VERSION_MINOR 11
-#define NEU_VERSION_FIX 3
+#define NEU_VERSION_FIX 4
 
 #define NEU_GET_VERSION_MAJOR(V) ((0xffff0000 & V) >> 16)
 #define NEU_GET_VERSION_MINOR(V) ((0x0000ff00 & V) >> 8)

include/neuron/msg.h

@@ -326,11 +326,21 @@ typedef struct neu_req_get_node {
     neu_node_type_e type;
     char            plugin[NEU_PLUGIN_NAME_LEN];
     char            node[NEU_NODE_NAME_LEN];
+
+    struct {
+        bool q_state;
+        int  state;
+        bool q_link;
+        int  link;
+        bool s_delay;
+        char q_group_name[NEU_GROUP_NAME_LEN];
+    } query;
 } neu_req_get_node_t;
 
 typedef struct neu_resp_node_info {
-    char node[NEU_NODE_NAME_LEN];
-    char plugin[NEU_PLUGIN_NAME_LEN];
+    int64_t delay;
+    char    node[NEU_NODE_NAME_LEN];
+    char    plugin[NEU_PLUGIN_NAME_LEN];
 } neu_resp_node_info_t;
 
 typedef struct neu_resp_get_node {
@@ -368,6 +378,7 @@ typedef struct neu_req_del_group {
 
 typedef struct neu_req_get_group {
     char driver[NEU_NODE_NAME_LEN];
+    char q_group[NEU_GROUP_NAME_LEN];
 } neu_req_get_group_t;
 
 typedef struct neu_resp_group_info {
@@ -722,10 +733,11 @@ typedef struct neu_resp_tag_value {
 typedef neu_resp_tag_value_t neu_tag_value_t;
 
 typedef struct neu_resp_tag_value_meta {
-    char           tag[NEU_TAG_NAME_LEN];
-    neu_dvalue_t   value;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
-    neu_datatag_t  datatag;
+    char            tag[NEU_TAG_NAME_LEN];
+    neu_dvalue_t    value;
+    neu_tag_meta_t *metas;
+    int             n_meta;
+    neu_datatag_t   datatag;
 } neu_resp_tag_value_meta_t;
 
 static inline UT_icd *neu_resp_tag_value_meta_icd()
@@ -786,10 +798,11 @@ typedef struct {
 } neu_resp_read_group_t;
 
 typedef struct neu_resp_tag_value_meta_paginate {
-    char           tag[NEU_TAG_NAME_LEN];
-    neu_dvalue_t   value;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
-    neu_datatag_t  datatag;
+    char            tag[NEU_TAG_NAME_LEN];
+    neu_dvalue_t    value;
+    neu_tag_meta_t *metas;
+    int             n_meta;
+    neu_datatag_t   datatag;
 } neu_resp_tag_value_meta_paginate_t;
 
 static inline UT_icd *neu_resp_tag_value_meta_paginate_icd()
@@ -820,6 +833,13 @@ static inline void neu_resp_read_free(neu_resp_read_group_t *resp)
                    tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
             free(tag_value->value.value.bools.bools);
         }
+
+        if (tag_value->metas != NULL) {
+            for (int i = 0; i < tag_value->n_meta; i++) {
+                neu_free_dvalue(&tag_value->metas[i].value);
+            }
+            free(tag_value->metas);
+        }
     }
     free(resp->driver);
     free(resp->group);
@@ -837,6 +857,13 @@ neu_resp_read_paginate_free(neu_resp_read_group_paginate_t *resp)
                    tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
             free(tag_value->value.value.bools.bools);
         }
+
+        if (tag_value->metas != NULL) {
+            for (int i = 0; i < tag_value->n_meta; i++) {
+                neu_free_dvalue(&tag_value->metas[i].value);
+            }
+            free(tag_value->metas);
+        }
     }
     free(resp->driver);
     free(resp->group);
@@ -914,6 +941,13 @@ static inline void neu_trans_data_free(neu_reqresp_trans_data_t *data)
                        tag_value->value.type < NEU_TYPE_ARRAY_STRING) {
                 free(tag_value->value.value.bools.bools);
             }
+
+            if (tag_value->metas != NULL) {
+                for (int i = 0; i < tag_value->n_meta; i++) {
+                    neu_free_dvalue(&tag_value->metas[i].value);
+                }
+                free(tag_value->metas);
+            }
         }
         utarray_free(data->tags);
         free(data->group);
@@ -932,18 +966,21 @@ static inline void neu_tag_value_to_json(neu_resp_tag_value_meta_t *tag_value,
     tag_json->name  = tag_value->tag;
     tag_json->error = 0;
 
-    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-        if (strlen(tag_value->metas[k].name) > 0) {
-            tag_json->n_meta++;
-        } else {
-            break;
-        }
-    }
+    // for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
+    //     if (strlen(tag_value->metas[k].name) > 0) {
+    //         tag_json->n_meta++;
+    //     } else {
+    //         break;
+    //     }
+    // }
+
+    tag_json->n_meta = tag_value->n_meta;
+
     if (tag_json->n_meta > 0) {
         tag_json->metas = (neu_json_tag_meta_t *) calloc(
             tag_json->n_meta, sizeof(neu_json_tag_meta_t));
     }
-    neu_json_metas_to_json(tag_value->metas, NEU_TAG_META_SIZE, tag_json);
+    neu_json_metas_to_json(tag_value->metas, tag_value->n_meta, tag_json);
 
     tag_json->datatag.bias = tag_value->datatag.bias;
 
@@ -1141,18 +1178,21 @@ neu_tag_value_to_json_paginate(neu_resp_tag_value_meta_paginate_t *tag_value,
     memcpy(tag_json->datatag.meta, tag_value->datatag.meta,
            NEU_TAG_META_LENGTH);
 
-    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-        if (strlen(tag_value->metas[k].name) > 0) {
-            tag_json->n_meta++;
-        } else {
-            break;
-        }
-    }
+    // for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
+    //     if (strlen(tag_value->metas[k].name) > 0) {
+    //         tag_json->n_meta++;
+    //     } else {
+    //         break;
+    //     }
+    // }
+
+    tag_json->n_meta = tag_value->n_meta;
+
     if (tag_json->n_meta > 0) {
         tag_json->metas = (neu_json_tag_meta_t *) calloc(
             tag_json->n_meta, sizeof(neu_json_tag_meta_t));
     }
-    neu_json_metas_to_json_paginate(tag_value->metas, NEU_TAG_META_SIZE,
+    neu_json_metas_to_json_paginate(tag_value->metas, tag_value->n_meta,
                                     tag_json);
 
     switch (tag_value->value.type) {

plugins/restful/adapter_handle.c

@@ -145,6 +145,7 @@ void handle_get_adapter(nng_aio *aio)
     int  ret                              = 0;
     char plugin_name[NEU_PLUGIN_NAME_LEN] = { 0 };
     char node_name[NEU_NODE_NAME_LEN]     = { 0 };
+    char group_name[NEU_GROUP_NAME_LEN]   = { 0 };
 
     neu_plugin_t *     plugin    = neu_rest_get_plugin();
     neu_node_type_e    node_type = { 0 };
@@ -173,6 +174,33 @@ void handle_get_adapter(nng_aio *aio)
         strcpy(cmd.node, node_name);
     }
 
+    if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
+        0) {
+        strcpy(cmd.query.q_group_name, group_name);
+    }
+
+    uintmax_t query_state = 0;
+    if (neu_http_get_param_uintmax(aio, "state", &query_state) == 0) {
+        if (query_state == 1 || query_state == 2 || query_state == 3 ||
+            query_state == 4) {
+            cmd.query.q_state = true;
+            cmd.query.state   = (int) query_state;
+        }
+    }
+
+    uintmax_t query_link = 0;
+    if (neu_http_get_param_uintmax(aio, "link", &query_link) == 0) {
+        if (query_link == 0 || query_link == 1) {
+            cmd.query.q_link = true;
+            cmd.query.link   = (int) query_link;
+        }
+    }
+
+    uintmax_t sort_delay = 0;
+    if (neu_http_get_param_uintmax(aio, "delay", &sort_delay) == 0) {
+        cmd.query.s_delay = true;
+    }
+
     cmd.type = node_type;
     ret      = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {

plugins/restful/group_config_handle.c

@@ -160,11 +160,12 @@ void handle_del_group_config(nng_aio *aio)
 
 void handle_get_group_config(nng_aio *aio)
 {
-    neu_plugin_t *      plugin                       = neu_rest_get_plugin();
-    char                node_name[NEU_NODE_NAME_LEN] = { 0 };
-    int                 ret                          = 0;
-    neu_req_get_group_t cmd                          = { 0 };
-    neu_reqresp_head_t  header                       = {
+    neu_plugin_t *      plugin                         = neu_rest_get_plugin();
+    char                node_name[NEU_NODE_NAME_LEN]   = { 0 };
+    char                group_name[NEU_GROUP_NAME_LEN] = { 0 };
+    int                 ret                            = 0;
+    neu_req_get_group_t cmd                            = { 0 };
+    neu_reqresp_head_t  header                         = {
         .ctx             = aio,
         .type            = NEU_REQ_GET_GROUP,
         .otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM,
@@ -178,6 +179,11 @@ void handle_get_group_config(nng_aio *aio)
         header.type = NEU_REQ_GET_DRIVER_GROUP;
     }
 
+    if (neu_http_get_param_str(aio, "group", group_name, sizeof(group_name)) >
+        0) {
+        strcpy(cmd.q_group, group_name);
+    }
+
     ret = neu_plugin_op(plugin, header, &cmd);
     if (ret != 0) {
         NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {

src/adapter/adapter.c

@@ -1033,12 +1033,15 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_GET_GROUP: {
+
+        neu_req_get_group_t *cmd = (neu_req_get_group_t *) &header[1];
+
         neu_msg_exchange(header);
 
         if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
             neu_resp_get_group_t resp = {
                 .groups = neu_adapter_driver_get_group(
-                    (neu_adapter_driver_t *) adapter)
+                    (neu_adapter_driver_t *) adapter, cmd->q_group)
             };
             header->type = NEU_RESP_GET_GROUP;
             reply(adapter, header, &resp);
@@ -1736,6 +1739,16 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter)
     return state;
 }
 
+UT_array *neu_adapter_get_groups(neu_adapter_t *adapter, const char *filter)
+{
+    if (adapter->module->type != NEU_NA_TYPE_DRIVER) {
+        return NULL;
+    } else {
+        return neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter,
+                                            filter);
+    }
+}
+
 neu_event_timer_t *neu_adapter_add_timer(neu_adapter_t *         adapter,
                                          neu_event_timer_param_t param)
 {

src/adapter/adapter_internal.h

@@ -95,6 +95,7 @@ void neu_adapter_del_timer(neu_adapter_t *adapter, neu_event_timer_t *timer);
 int neu_adapter_set_setting(neu_adapter_t *adapter, const char *config);
 int neu_adapter_get_setting(neu_adapter_t *adapter, char **config);
 neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter);
+UT_array *neu_adapter_get_groups(neu_adapter_t *adapter, const char *filter);
 
 static inline void neu_adapter_reset_metrics(neu_adapter_t *adapter)
 {

src/adapter/driver/cache.c

@@ -45,7 +45,8 @@ struct elem {
     neu_dvalue_t value;
     neu_dvalue_t value_old;
 
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
+    neu_tag_meta_t *metas;
+    int             n_meta;
 
     tkey_t         key;
     UT_hash_handle hh;
@@ -115,6 +116,13 @@ void neu_driver_cache_destroy(neu_driver_cache_t *cache)
             free(elem->value.value.bools.bools);
         }
 
+        if (elem->metas != NULL) {
+            for (int i = 0; i < elem->n_meta; i++) {
+                neu_free_dvalue(&elem->metas[i].value);
+            }
+            free(elem->metas);
+        }
+
         free(elem);
     }
 
@@ -764,9 +772,16 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
         }
         elem->value.type = value.type;
 
-        memset(elem->metas, 0, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
-        for (int i = 0; i < n_meta; i++) {
-            memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+        if (metas != NULL) {
+            if (elem->metas != NULL) {
+                free(elem->metas);
+            }
+            elem->metas = calloc(n_meta, sizeof(neu_tag_meta_t));
+            for (int i = 0; i < n_meta; i++) {
+                memcpy(&elem->metas[i], &metas[i], sizeof(neu_tag_meta_t));
+            }
+
+            elem->n_meta = n_meta;
         }
     }
 
@@ -784,7 +799,7 @@ void neu_driver_cache_update(neu_driver_cache_t *cache, const char *group,
 
 int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
                               const char *tag, neu_driver_cache_value_t *value,
-                              neu_tag_meta_t *metas, int n_meta)
+                              neu_tag_meta_t **metas, int *n_meta)
 {
     struct elem *elem = NULL;
     int          ret  = -1;
@@ -798,8 +813,14 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
         value->value.type      = elem->value.type;
         value->value.precision = elem->value.precision;
 
-        assert(n_meta <= NEU_TAG_META_SIZE);
-        memcpy(metas, elem->metas, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
+        // assert(n_meta <= NEU_TAG_META_SIZE);
+        if (elem->metas) {
+            *metas = calloc(elem->n_meta, sizeof(neu_tag_meta_t));
+            memcpy(*metas, elem->metas, sizeof(neu_tag_meta_t) * elem->n_meta);
+        } else {
+            *metas = NULL;
+        }
+        *n_meta = elem->n_meta;
 
         switch (elem->value.type) {
         case NEU_TYPE_INT8:
@@ -941,13 +962,6 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
             break;
         }
 
-        for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (strlen(elem->metas[i].name) > 0) {
-                memcpy(&value->metas[i], &elem->metas[i],
-                       sizeof(neu_tag_meta_t));
-            }
-        }
-
         ret = 0;
     }
 
@@ -959,7 +973,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
 int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
                                       const char *group, const char *tag,
                                       neu_driver_cache_value_t *value,
-                                      neu_tag_meta_t *metas, int n_meta)
+                                      neu_tag_meta_t **metas, int *n_meta)
 {
     struct elem *elem = NULL;
     int          ret  = -1;
@@ -973,8 +987,14 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
         value->value.type      = elem->value.type;
         value->value.precision = elem->value.precision;
 
-        assert(n_meta <= NEU_TAG_META_SIZE);
-        memcpy(metas, elem->metas, sizeof(neu_tag_meta_t) * NEU_TAG_META_SIZE);
+        // assert(n_meta <= NEU_TAG_META_SIZE);
+        if (elem->metas) {
+            *metas = calloc(elem->n_meta, sizeof(neu_tag_meta_t));
+            memcpy(*metas, elem->metas, sizeof(neu_tag_meta_t) * elem->n_meta);
+        } else {
+            *metas = NULL;
+        }
+        *n_meta = elem->n_meta;
 
         switch (elem->value.type) {
         case NEU_TYPE_INT8:
@@ -1116,13 +1136,6 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
             break;
         }
 
-        for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (strlen(elem->metas[i].name) > 0) {
-                memcpy(&value->metas[i], &elem->metas[i],
-                       sizeof(neu_tag_meta_t));
-            }
-        }
-
         if (elem->value.type != NEU_TYPE_ERROR) {
             elem->changed = false;
         }
@@ -1165,6 +1178,12 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
                    elem->value.type < NEU_TYPE_ARRAY_STRING) {
             free(elem->value.value.bools.bools);
         }
+        if (elem->metas != NULL) {
+            for (int i = 0; i < elem->n_meta; i++) {
+                neu_free_dvalue(&elem->metas[i].value);
+            }
+            free(elem->metas);
+        }
         free(elem);
     }
 

src/adapter/driver/cache.h

@@ -50,17 +50,16 @@ void neu_driver_cache_update_trace(neu_driver_cache_t *cache, const char *group,
 void *neu_driver_cache_get_trace(neu_driver_cache_t *cache, const char *group);
 
 typedef struct {
-    neu_dvalue_t   value;
-    int64_t        timestamp;
-    neu_tag_meta_t metas[NEU_TAG_META_SIZE];
+    neu_dvalue_t value;
+    int64_t      timestamp;
 } neu_driver_cache_value_t;
 
 int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
                               const char *tag, neu_driver_cache_value_t *value,
-                              neu_tag_meta_t *metas, int n_meta);
+                              neu_tag_meta_t **metas, int *n_meta);
 int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
                                       const char *group, const char *tag,
                                       neu_driver_cache_value_t *value,
-                                      neu_tag_meta_t *metas, int n_meta);
+                                      neu_tag_meta_t **metas, int *n_meta);
 
 #endif

src/adapter/driver/driver.c

@@ -1757,7 +1757,8 @@ int neu_adapter_driver_group_exist(neu_adapter_driver_t *driver,
     return ret;
 }
 
-UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver)
+UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver,
+                                       const char *          filter)
 {
     group_t * el = NULL, *tmp = NULL;
     UT_array *groups = NULL;
@@ -1767,13 +1768,16 @@ UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver)
 
     HASH_ITER(hh, driver->groups, el, tmp)
     {
-        neu_resp_group_info_t info = { 0 };
 
-        info.interval  = neu_group_get_interval(el->group);
-        info.tag_count = neu_group_tag_size(el->group);
-        strncpy(info.name, el->name, sizeof(info.name));
+        if (strlen(filter) == 0 || strstr(el->name, filter) != NULL) {
+            neu_resp_group_info_t info = { 0 };
 
-        utarray_push_back(groups, &info);
+            info.interval  = neu_group_get_interval(el->group);
+            info.tag_count = neu_group_tag_size(el->group);
+            strncpy(info.name, el->name, sizeof(info.name));
+
+            utarray_push_back(groups, &info);
+        }
     }
 
     return groups;
@@ -2126,6 +2130,7 @@ static int report_callback(void *usr_data)
     data->driver = strdup(group->driver->adapter.name);
     data->group  = strdup(group->name);
     utarray_new(data->tags, neu_resp_tag_value_meta_icd());
+    utarray_reserve(data->tags, utarray_len(tags));
 
     void *trace_ctx =
         neu_driver_cache_get_trace(group->driver->cache, group->name);
@@ -2217,6 +2222,13 @@ static int report_callback(void *usr_data)
                 } else {
                     neu_free_dvalue(&tag_value->value);
                 }
+
+                if (tag_value->metas != NULL) {
+                    for (int i = 0; i < tag_value->n_meta; i++) {
+                        neu_free_dvalue(&tag_value->metas[i].value);
+                    }
+                    free(tag_value->metas);
+                }
             }
             utarray_free(data->tags);
             free(data->group);
@@ -2421,15 +2433,15 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
 
         if (neu_tag_attribute_test(tag, NEU_ATTRIBUTE_SUBSCRIBE)) {
             if (neu_driver_cache_meta_get_changed(cache, group, tag->name,
-                                                  &value, tag_value.metas,
-                                                  NEU_TAG_META_SIZE) != 0) {
+                                                  &value, &tag_value.metas,
+                                                  &tag_value.n_meta) != 0) {
                 nlog_debug("tag: %s not changed", tag->name);
                 continue;
             }
         } else {
             if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                          tag_value.metas,
-                                          NEU_TAG_META_SIZE) != 0) {
+                                          &tag_value.metas,
+                                          &tag_value.n_meta) != 0) {
                 strcpy(tag_value.tag, tag->name);
                 tag_value.value.type      = NEU_TYPE_ERROR;
                 tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
@@ -2616,8 +2628,8 @@ static void read_group(int64_t timestamp, int64_t timeout,
         tag_value.datatag.bias = tag->bias;
 
         if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                      tag_value.metas,
-                                      NEU_TAG_META_SIZE) != 0) {
+                                      &tag_value.metas,
+                                      &tag_value.n_meta) != 0) {
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
 
@@ -2804,8 +2816,8 @@ static void read_group_paginate(int64_t timestamp, int64_t timeout,
         }
 
         if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                      tag_value.metas,
-                                      NEU_TAG_META_SIZE) != 0) {
+                                      &tag_value.metas,
+                                      &tag_value.n_meta) != 0) {
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
 

src/adapter/driver/driver_internal.h

@@ -54,7 +54,8 @@ int neu_adapter_driver_del_group(neu_adapter_driver_t *driver,
                                  const char *          name);
 int neu_adapter_driver_group_exist(neu_adapter_driver_t *driver,
                                    const char *          name);
-UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver);
+UT_array *neu_adapter_driver_get_group(neu_adapter_driver_t *driver,
+                                       const char *          filter);
 uint16_t  neu_adapter_driver_group_count(neu_adapter_driver_t *driver);
 uint16_t  neu_adapter_driver_new_group_count(neu_adapter_driver_t *driver,
                                              neu_req_add_gtag_t *  cmd);

src/core/manager.c

@@ -435,7 +435,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_error_t      e   = { 0 };
 
         UT_array *nodes = neu_manager_get_nodes(
-            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, cmd->plugin, "");
+            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, cmd->plugin, "",
+            false, false, 0, false, 0, "");
 
         if (nodes != NULL) {
             if (utarray_len(nodes) > 0) {
@@ -616,7 +617,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         }
 
         UT_array *nodes = neu_manager_get_nodes(
-            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, module_name, "");
+            manager, NEU_NA_TYPE_DRIVER | NEU_NA_TYPE_APP, module_name, "",
+            false, false, 0, false, 0, "");
 
         if (nodes != NULL) {
             if (utarray_len(nodes) > 0) {
@@ -866,9 +868,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_GET_NODE: {
-        neu_req_get_node_t *cmd = (neu_req_get_node_t *) &header[1];
-        UT_array *          nodes =
-            neu_manager_get_nodes(manager, cmd->type, cmd->plugin, cmd->node);
+        neu_req_get_node_t *cmd   = (neu_req_get_node_t *) &header[1];
+        UT_array *          nodes = neu_manager_get_nodes(
+            manager, cmd->type, cmd->plugin, cmd->node, cmd->query.s_delay,
+            cmd->query.q_state, cmd->query.state, cmd->query.q_link,
+            cmd->query.link, cmd->query.q_group_name);
         neu_resp_get_node_t resp = { .nodes = nodes };
 
         header->type = NEU_RESP_GET_NODE;

src/core/manager_internal.c

@@ -114,9 +114,13 @@ int neu_manager_del_node(neu_manager_t *manager, const char *node_name)
 }
 
 UT_array *neu_manager_get_nodes(neu_manager_t *manager, int type,
-                                const char *plugin, const char *node)
+                                const char *plugin, const char *node,
+                                bool sort_delay, bool q_state, int state,
+                                bool q_link, int link, const char *q_group_name)
 {
-    return neu_node_manager_filter(manager->node_manager, type, plugin, node);
+    return neu_node_manager_filter(manager->node_manager, type, plugin, node,
+                                   sort_delay, q_state, state, q_link, link,
+                                   q_group_name);
 }
 
 int neu_manager_update_node_name(neu_manager_t *manager, const char *node,
@@ -182,7 +186,7 @@ UT_array *neu_manager_get_driver_group(neu_manager_t *manager)
         neu_adapter_t *adapter =
             neu_node_manager_find(manager->node_manager, driver->node);
         UT_array *groups =
-            neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter);
+            neu_adapter_driver_get_group((neu_adapter_driver_t *) adapter, "");
 
         utarray_foreach(groups, neu_resp_group_info_t *, g)
         {

src/core/manager_internal.h

@@ -56,7 +56,10 @@ int       neu_manager_add_node(neu_manager_t *manager, const char *node_name,
                                neu_node_running_state_e state, bool load);
 int       neu_manager_del_node(neu_manager_t *manager, const char *node_name);
 UT_array *neu_manager_get_nodes(neu_manager_t *manager, int type,
-                                const char *plugin, const char *node);
+                                const char *plugin, const char *node,
+                                bool sort_delay, bool q_state, int state,
+                                bool q_link, int link,
+                                const char *q_group_name);
 int       neu_manager_update_node_name(neu_manager_t *manager, const char *node,
                                        const char *new_name);
 int neu_manager_update_group_name(neu_manager_t *manager, const char *driver,

src/core/node_manager.c

@@ -194,8 +194,24 @@ UT_array *neu_node_manager_get(neu_node_manager_t *mgr, int type)
     return array;
 }
 
+static int neu_resp_node_info_sort(const void *a, const void *b)
+{
+    const neu_resp_node_info_t *info_a = (const neu_resp_node_info_t *) a;
+    const neu_resp_node_info_t *info_b = (const neu_resp_node_info_t *) b;
+
+    if (info_a->delay < info_b->delay) {
+        return -1;
+    } else if (info_a->delay > info_b->delay) {
+        return 1;
+    }
+    return 0;
+}
+
 UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
-                                  const char *plugin, const char *node)
+                                  const char *plugin, const char *node,
+                                  bool sort_delay, bool q_state, int state,
+                                  bool q_link, int link,
+                                  const char *q_group_name)
 {
     UT_array *     array = NULL;
     UT_icd         icd   = { sizeof(neu_resp_node_info_t), NULL, NULL, NULL };
@@ -215,14 +231,57 @@ UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
                     strstr(el->adapter->name, node) == NULL) {
                     continue;
                 }
+                if (q_state) {
+                    if (el->adapter->state !=
+                        (neu_node_running_state_e) state) {
+                        continue;
+                    }
+                }
+                if (q_link) {
+                    neu_node_state_t node_state =
+                        neu_adapter_get_state(el->adapter);
+                    if (node_state.link != (neu_node_link_state_e) link) {
+                        continue;
+                    }
+                }
+
+                if (strlen(q_group_name) > 0) {
+                    if (strstr(el->adapter->name, q_group_name) == NULL) {
+                        UT_array *groups =
+                            neu_adapter_get_groups(el->adapter, q_group_name);
+                        if (NULL == groups || utarray_len(groups) == 0) {
+                            if (groups != NULL) {
+                                utarray_free(groups);
+                            }
+                            continue;
+                        } else {
+                            utarray_free(groups);
+                        }
+                    }
+                }
+
                 neu_resp_node_info_t info = { 0 };
                 strcpy(info.node, el->adapter->name);
                 strcpy(info.plugin, el->adapter->module->module_name);
+                if (sort_delay) {
+                    neu_metric_entry_t *e = NULL;
+                    if (NULL != el->adapter->metrics) {
+                        HASH_FIND_STR(el->adapter->metrics->entries,
+                                      NEU_METRIC_LAST_RTT_MS, e);
+                    }
+                    info.delay = NULL != e ? e->value : 0;
+                } else {
+                    info.delay = 0;
+                }
                 utarray_push_back(array, &info);
             }
         }
     }
 
+    if (sort_delay) {
+        utarray_sort(array, neu_resp_node_info_sort);
+    }
+
     return array;
 }
 

src/core/node_manager.h

@@ -49,7 +49,10 @@ uint16_t neu_node_manager_size(neu_node_manager_t *mgr);
 // neu_resp_node_info array
 UT_array *neu_node_manager_get(neu_node_manager_t *mgr, int type);
 UT_array *neu_node_manager_filter(neu_node_manager_t *mgr, int type,
-                                  const char *plugin, const char *node);
+                                  const char *plugin, const char *node,
+                                  bool sort_delay, bool q_state, int state,
+                                  bool q_link, int link,
+                                  const char *q_group_name);
 UT_array *neu_node_manager_get_all(neu_node_manager_t *mgr);
 
 // neu_adapter_t array

tests/ft/http_api/test_http_api.py

@@ -610,6 +610,39 @@ class TestHttp:
         response = api.get_status()
         assert 200 == response.status_code
 
+    @description(given="running neuron", when="get node or group by filter", then="success")
+    def test_get_node_or_group_by_filter(self):
+        node_1 = "test1"
+        node_2 = "test2"
+        group_1 = "abcd1"
+        group_2 = "abdc2"
+        api.add_node_check(node_1, 'Modbus TCP')
+        api.add_node_check(node_2, 'Modbus TCP')
+        api.add_group_check(node_1, group_1, 1000)
+        api.add_group_check(node_1, group_2, 1000)
+        api.add_group_check(node_2, group_1, 1000)
+        # api.add_group_check(node_2, group_2, 1000)
+
+        response = api.get_nodes(1)
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="dc")
+        assert 1 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="ab")
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="test")
+        assert 2 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="test1")
+        assert 1 == len(response.json()["nodes"])
+        response = api.get_nodes(1, group="1234")
+        assert 0 == len(response.json()["nodes"])
+        response = api.get_group(node=node_1)
+        assert 2 == len(response.json()["groups"])
+        response = api.get_group(node=node_1, group="1")
+        assert 1 == len(response.json()["groups"])
+        response = api.get_group(node=node_2)
+        assert 1 == len(response.json()["groups"])
+
+
     @description(given="running neuron", when="test jwt error", then="failed")
     def test_jwt_err(self):
         response = api.change_password(new_password='123456', jwt='invalid')
@@ -629,3 +662,5 @@ class TestHttp:
 
         response = api.delete_virtual_license(jwt='invalid')
         assert 404 == response.status_code
+
+

tests/ft/neuron/api.py

@@ -79,8 +79,11 @@ def del_node(node, jwt=config.default_jwt):
     return requests.delete(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, json={"name": node})
 
 
-def get_nodes(type, jwt=config.default_jwt):
-    return requests.get(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, params={"type": type})
+def get_nodes(type, jwt=config.default_jwt, group=""):
+    if group == "":
+        return requests.get(url=config.BASE_URL + '/api/v2/node', headers={"Authorization": jwt}, params={"type": type})
+    else:
+        return requests.get(url=config.BASE_URL + '/api/v2/node?group=' + group, headers={"Authorization": jwt}, params={"type": type})
 
 
 @gen_check
@@ -124,8 +127,13 @@ def update_group(node, group, new_name="", interval=0):
 
 
 @gen_check
-def get_group(node=""):
-    return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}', headers={"Authorization": config.default_jwt})
+def get_group(node="", group=""):
+    if group == "":
+        return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}', headers={"Authorization": config.default_jwt})
+    else:
+        return requests.get(url=config.BASE_URL + f'/api/v2/group?node={node}&group={group}', headers={"Authorization": config.default_jwt})
+
+
 
 
 @gen_check

version

@@ -1 +1 @@
-2.11.3
+2.11.4