Merge pull request #1887 from fengzeroz/v2.6

version: 2.6.6

.github/workflows/ci.yml

@@ -8,8 +8,8 @@ on:
       - published
 
 env:
-  VERSION: 2.6.1
-  UI_VERSION: 2.6.1
+  VERSION: 2.6.6
+  UI_VERSION: 2.6.3
   BRANCH: v2.6
 
 jobs:

CMakeLists.txt

@@ -41,7 +41,7 @@ if(USE_GCOV)
 endif(USE_GCOV)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -g")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} -O1")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} -O0")
 
 if(NOT DISABLE_ASAN)
   set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -fsanitize=address")
@@ -74,6 +74,7 @@ set(NEURON_BASE_SOURCES
     src/base/tag_sort.c
     src/base/group.c
     src/base/metrics.c
+    src/base/msg.c
     src/base/template.c
     src/connection/connection.c
     src/connection/connection_eth.c
@@ -102,7 +103,7 @@ add_library(neuron-base SHARED)
 target_sources(neuron-base PRIVATE ${NEURON_BASE_SOURCES} ${NEURON_SRC_PARSE}) 
 target_include_directories(neuron-base
                            PRIVATE include/neuron src)
-target_link_libraries(neuron-base libssl.a libcrypto.a)
+target_link_libraries(neuron-base atomic libssl.a libcrypto.a)
 target_link_libraries(neuron-base nng libzlog.so jansson jwt
                       ${CMAKE_THREAD_LIBS_INIT})
 add_dependencies(neuron-base neuron-version)
@@ -122,13 +123,13 @@ set(NEURON_SOURCES
     src/core/node_manager.c
     src/core/template_manager.c
     src/core/storage.c
+    src/adapter/msg_q.c
     src/adapter/storage.c
     src/adapter/adapter.c
     src/adapter/driver/cache.c
     src/adapter/driver/driver.c
     plugins/restful/handle.c
     plugins/restful/log_handle.c
-    plugins/restful/file_handle.c
     plugins/restful/metric_handle.c
     plugins/restful/normal_handle.c
     plugins/restful/rw_handle.c

dev.conf

@@ -6,10 +6,10 @@ file perms = 666
 
 stdout_format = "%d:%ms [%V] [%c] %f:%L %m%n"
 file_format = "%d:%ms [%V] %f:%L %m%n"
-syslog = "%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
+syslog = "<P>%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
 
 [rules]
 
-*.*     "./logs/%c.log", 50MB * 1 ~ "./logs/%c.#2s.log"; file_format
+*.*     "./logs/%c.log", 25MB * 1 ~ "./logs/%c.#2r.log"; file_format
 *.*    	>stdout; stdout_format
-*.*     $remote_syslog; syslog
+*.*     $remote_syslog,"%V"; syslog

ft/modbus_tcp_test.robot

@@ -154,6 +154,22 @@ Read all type tag with same slave id in input register and input, it should be s
 	${input_bit_4}    input_bit_4    ${modbus_tcp_node}    Compare Tag Value As Int    0
 	${input_bit_5}    input_bit_5    ${modbus_tcp_node}    Compare Tag Value As Int    0	
 
+Read in sync mode, it should fail.
+	${res}=	Add Group  ${modbus_tcp_node}  group  100
+	Check Response Status  ${res}  200
+	Check Error Code  ${res}  ${NEU_ERR_SUCCESS}
+
+	${res}=	Add Tags  ${modbus_tcp_node}  group  ${input_register_int16},${input_register_uint16},${input_register_int32},${input_register_uint32},${input_register_float},${input_register_string},${input_register_bit}
+	Check Response Status  ${res}  200
+	Check Error Code  ${res}  ${NEU_ERR_SUCCESS}
+
+	Sleep 	290ms
+	${res}=	Read Tags  ${modbus_tcp_node}  group  true
+	Check Response Status  ${res}  200
+	Check Response Status  ${res}  ${NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC}
+
+	[Teardown]	Del Group  ${modbus_tcp_node}  group
+
 Read some tags at time, it will be success.
 	[Template] 	Read some ${tags} from ${node}, it will be success.
 	${input_register_int16},${input_register_uint16},${input_register_int32},${input_register_uint32},${input_register_float},${input_register_string},${input_register_bit} 	${modbus_tcp_node}

ft/normal_test.robot

@@ -9,12 +9,12 @@ Suite Teardown	Stop Neuronx
 login with invalid username, it should return failure
     POST       /api/v2/login      {"name":"admin1", "pass": "0000"}
     Integer    response status    401
-    Integer    $.error            ${NEU_ERR_INVALID_USER}
+    Integer    $.error            ${NEU_ERR_INVALID_USER_OR_PASSWORD}
 
 login with invalid password, it should return failure
     POST       /api/v2/login      {"name":"admin", "pass": "2333"}
     Integer    response status    401
-    Integer    $.error            ${NEU_ERR_INVALID_PASSWORD}
+    Integer    $.error            ${NEU_ERR_INVALID_USER_OR_PASSWORD}
 
 login with username and password, it should return success
     POST       /api/v2/login      {"name":"admin", "pass": "0000"}

ft/resource/api.resource

@@ -197,8 +197,8 @@ Del Tags
   [RETURN]            ${res}[0]
 
 Read Tags
-  [Arguments]         ${node}              ${group}
-  POST                /api/v2/read            {"node": "${node}", "group": "${group}"}
+  [Arguments]         ${node}              ${group}                      ${sync}=false
+  POST                /api/v2/read            {"node": "${node}", "group": "${group}", "sync": ${sync}}
   ${res} =            Object  response body
   [RETURN]            ${res}[0]
 

ft/resource/error.resource

@@ -95,5 +95,6 @@ ${NEU_ERR_PLUGIN_NOT_FOUND}                     3014
 ${NEU_ERR_PLUGIN_DEVICE_NOT_RESPONSE}           3015
 ${NEU_ERR_PLUGIN_NOT_SUPPORT_TEMPLATE}          3016
 ${NEU_ERR_PLUGIN_NOT_SUPPORT_WRITE_TAGS}        3017
+${NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC}         3018
 
 ${NEU_ERR_MQTT_SUBSCRIBE_FAILURE}               4010

include/neuron/define.h

@@ -85,4 +85,7 @@ typedef enum {
     NEU_TAG_CACHE_TYPE_NEVER,
 } neu_tag_cache_type_e;
 
+// forward declaration for neu_adapter_t
+typedef struct neu_adapter neu_adapter_t;
+
 #endif

include/neuron/errcodes.h

@@ -47,8 +47,6 @@ typedef enum {
     NEU_ERR_COMMAND_EXECUTION_FAILED = 1014,
     NEU_ERR_IP_ADDRESS_INVALID       = 1015,
     NEU_ERR_IP_ADDRESS_IN_USE        = 1016,
-    NEU_ERR_INVALID_USER             = 1017,
-    NEU_ERR_INVALID_PASSWORD         = 1018,
 
     NEU_ERR_NODE_EXIST               = 2002,
     NEU_ERR_NODE_NOT_EXIST           = 2003,
@@ -102,6 +100,7 @@ typedef enum {
     NEU_ERR_LICENSE_TOKEN_NOT_MATCH = 2406,
     NEU_ERR_LICENSE_BAD_CLOCK       = 2407,
     NEU_ERR_LICENSE_MODULE_INVALID  = 2408,
+    NEU_ERR_LICENSE_TOKEN_NOT_FOUND = 2409,
 
     NEU_ERR_TEMPLATE_EXIST         = 2500,
     NEU_ERR_TEMPLATE_NOT_FOUND     = 2501,
@@ -124,6 +123,7 @@ typedef enum {
     NEU_ERR_PLUGIN_DEVICE_NOT_RESPONSE     = 3015,
     NEU_ERR_PLUGIN_NOT_SUPPORT_TEMPLATE    = 3016,
     NEU_ERR_PLUGIN_NOT_SUPPORT_WRITE_TAGS  = 3017,
+    NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC   = 3018,
 
     NEU_ERR_MQTT_FAILURE                        = 4000,
     NEU_ERR_MQTT_NO_CERTFILESET                 = 4001,

include/neuron/json/json.h

@@ -78,6 +78,8 @@ void *neu_json_array();
 int   neu_json_decode_by_json(void *json, int size, neu_json_elem_t *ele);
 int   neu_json_decode(char *buf, int size, neu_json_elem_t *ele);
 int   neu_json_decode_array_size_by_json(void *json, char *child);
+int   neu_json_decode_array_elem(void *json, int index, int size,
+                                 neu_json_elem_t *ele);
 int   neu_json_decode_array_by_json(void *json, char *name, int index, int size,
                                     neu_json_elem_t *ele);
 int   neu_json_decode_array_size(char *buf, char *child);

include/neuron/json/neu_json_rw.h

@@ -94,6 +94,24 @@ int  neu_json_decode_write_tags_req_json(void *                      json_obj,
                                          neu_json_write_tags_req_t **result);
 void neu_json_decode_write_tags_req_free(neu_json_write_tags_req_t *req);
 
+typedef struct {
+    char *                      group;
+    int                         n_tag;
+    neu_json_write_tags_elem_t *tags;
+} neu_json_write_gtags_elem_t;
+typedef struct {
+    char *node;
+
+    int                          n_group;
+    neu_json_write_gtags_elem_t *groups;
+} neu_json_write_gtags_req_t;
+
+int  neu_json_decode_write_gtags_req(char *                       buf,
+                                     neu_json_write_gtags_req_t **result);
+int  neu_json_decode_write_gtags_req_json(void *                       json_obj,
+                                          neu_json_write_gtags_req_t **result);
+void neu_json_decode_write_gtags_req_free(neu_json_write_gtags_req_t *req);
+
 typedef struct {
     union {
         neu_json_write_req_t      single;
@@ -108,6 +126,7 @@ void neu_json_decode_write_free(neu_json_write_t *req);
 typedef struct {
     char *group;
     char *node;
+    bool  sync;
 } neu_json_read_req_t;
 
 int  neu_json_decode_read_req(char *buf, neu_json_read_req_t **result);

include/neuron/metrics.h

@@ -30,9 +30,6 @@ extern "C" {
 #include "type.h"
 #include "utils/uthash.h"
 
-// forward declaration for neu_adapter_t
-typedef struct neu_adapter neu_adapter_t;
-
 typedef enum {
     NEU_METRIC_TYPE_COUNTER,
     NEU_METRIC_TYPE_GAUAGE,

include/neuron/plugin.h

@@ -46,7 +46,6 @@ typedef struct neu_plugin_common {
     char                       name[NEU_NODE_NAME_LEN];
 
     neu_node_link_state_e link_state;
-    char                  log_level[NEU_LOG_LEVEL_LEN];
 
     zlog_category_t *log;
 } neu_plugin_common_t;
@@ -85,6 +84,7 @@ typedef struct neu_plugin_intf_funs {
         struct {
             int (*validate_tag)(neu_plugin_t *plugin, neu_datatag_t *tag);
             int (*group_timer)(neu_plugin_t *plugin, neu_plugin_group_t *group);
+            int (*group_sync)(neu_plugin_t *plugin, neu_plugin_group_t *group);
             int (*write_tag)(neu_plugin_t *plugin, void *req,
                              neu_datatag_t *tag, neu_value_u value);
             int (*write_tags)(

include/neuron/utils/log.h

@@ -21,11 +21,36 @@ config_ **/
 #define _NEU_LOG_H_
 
 #include <inttypes.h>
+#include <memory.h>
 
 #include "utils/zlog.h"
 
+#include "define.h"
+
 extern zlog_category_t *neuron;
 
+inline static const char *log_level_to_str(int level)
+{
+    switch (level) {
+    case ZLOG_LEVEL_FATAL:
+        return NEU_LOG_LEVEL_FATAL;
+    case ZLOG_LEVEL_ERROR:
+        return NEU_LOG_LEVEL_ERROR;
+    case ZLOG_LEVEL_WARN:
+        return NEU_LOG_LEVEL_WARN;
+    case ZLOG_LEVEL_NOTICE:
+        return NEU_LOG_LEVEL_NOTICE;
+    case ZLOG_LEVEL_INFO:
+        return NEU_LOG_LEVEL_INFO;
+    case ZLOG_LEVEL_DEBUG:
+        return NEU_LOG_LEVEL_DEBUG;
+    default:
+        return "UNKNOWN";
+    }
+}
+
+#define nlog_level_change(level) zlog_level_switch(neuron, level)
+
 #define nlog_fatal(...)                                    \
     zlog(neuron, __FILE__, sizeof(__FILE__) - 1, __func__, \
          sizeof(__func__) - 1, __LINE__, ZLOG_LEVEL_FATAL, __VA_ARGS__)
@@ -64,50 +89,53 @@ extern zlog_category_t *neuron;
     zlog((plugin)->common.log, __FILE__, sizeof(__FILE__) - 1, __func__, \
          sizeof(__func__) - 1, __LINE__, ZLOG_LEVEL_DEBUG, __VA_ARGS__)
 
-#define plog_send_protocol(plugin, bytes, n_byte)                            \
-    uint16_t log_protocol_buf_size = n_byte * 5 + 20;                        \
-    char *   log_protocol_buf      = calloc(log_protocol_buf_size, 1);       \
-    int      log_offset            = 0;                                      \
-    uint16_t tmp_n_byte            = n_byte;                                 \
-    log_offset = snprintf(log_protocol_buf, log_protocol_buf_size, ">>(%d)", \
-                          tmp_n_byte);                                       \
-    for (int i = 0; i < n_byte; i++) {                                       \
-        log_offset += snprintf(log_protocol_buf + log_offset,                \
-                               log_protocol_buf_size - log_offset,           \
-                               " 0x%02hhX", (bytes)[i]);                     \
-    }                                                                        \
-    plog_debug(plugin, "%s", log_protocol_buf);                              \
-    free(log_protocol_buf);
+enum neu_protocol_log_type {
+    NEU_PROTOCOL_SEND,
+    NEU_PROTOCOL_RECV,
+};
 
-#define plog_recv_protocol(plugin, bytes, n_byte)                            \
-    uint16_t log_protocol_buf_size = n_byte * 5 + 20;                        \
-    char *   log_protocol_buf      = calloc(log_protocol_buf_size, 1);       \
-    int      log_offset            = 0;                                      \
-    uint16_t tmp_n_byte            = n_byte;                                 \
-    log_offset = snprintf(log_protocol_buf, log_protocol_buf_size, "<<(%d)", \
-                          tmp_n_byte);                                       \
-    for (int i = 0; i < n_byte; i++) {                                       \
-        log_offset += snprintf(log_protocol_buf + log_offset,                \
-                               log_protocol_buf_size - log_offset,           \
-                               " 0x%02hhX", (bytes)[i]);                     \
-    }                                                                        \
-    plog_debug(plugin, "%s", log_protocol_buf);                              \
-    free(log_protocol_buf);
+inline static void zlog_protocol(zlog_category_t *log, uint8_t *bytes,
+                                 uint16_t                   n_byte,
+                                 enum neu_protocol_log_type type)
+{
+    static __thread char buf[2048] = { 0 };
+    int                  offset    = 0;
 
-#define zlog_recv_protocol(log, bytes, n_byte)                               \
-    uint16_t log_protocol_buf_size = n_byte * 5 + 20;                        \
-    char *   log_protocol_buf      = calloc(log_protocol_buf_size, 1);       \
-    int      log_offset            = 0;                                      \
-    uint16_t tmp_n_byte            = n_byte;                                 \
-    log_offset = snprintf(log_protocol_buf, log_protocol_buf_size, "<<(%d)", \
-                          tmp_n_byte);                                       \
-    for (int i = 0; i < n_byte; i++) {                                       \
-        log_offset += snprintf(log_protocol_buf + log_offset,                \
-                               log_protocol_buf_size - log_offset,           \
-                               " 0x%02hhX", (bytes)[i]);                     \
-    }                                                                        \
-    zlog_debug(log, "%s", log_protocol_buf);                                 \
-    free(log_protocol_buf);
+    memset(buf, 0, sizeof(buf));
+    if (type == NEU_PROTOCOL_SEND) {
+        offset = snprintf(buf, sizeof(buf) - 1, ">>(%d)", n_byte);
+    } else {
+        offset = snprintf(buf, sizeof(buf) - 1, "<<(%d)", n_byte);
+    }
+
+    for (int i = 0; i < n_byte; i++) {
+        if (sizeof(buf) > (size_t) offset && sizeof(buf) - offset > 10) {
+            int s_ret = snprintf(buf + offset, sizeof(buf) - offset - 1,
+                                 " 0x%02hhX", bytes[i]);
+            if (s_ret > 0) {
+                offset += s_ret;
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+
+    zlog_debug(log, "%s", buf);
+}
+
+#define zlog_send_protocol(log, bytes, n_byte) \
+    zlog_protocol(log, (uint8_t *) bytes, n_byte, NEU_PROTOCOL_SEND)
+
+#define zlog_recv_protocol(log, bytes, n_byte) \
+    zlog_protocol(log, (uint8_t *) bytes, n_byte, NEU_PROTOCOL_RECV)
+
+#define plog_recv_protocol(plugin, bytes, n_byte) \
+    zlog_recv_protocol((plugin)->common.log, bytes, n_byte)
+
+#define plog_send_protocol(plugin, bytes, n_byte) \
+    zlog_send_protocol((plugin)->common.log, bytes, n_byte)
 
 void remove_logs(const char *node);
 

include/neuron/utils/utextend.h

@@ -33,8 +33,12 @@ static inline UT_array *utarray_clone(UT_array *array)
     result->i   = array->i;
     result->n   = array->n;
     result->icd = array->icd;
-    result->d   = (char *) calloc(1, array->n * array->icd.sz);
-    memcpy(result->d, array->d, array->n * array->icd.sz);
+    if (array->n > 0) {
+        result->d = (char *) calloc(1, array->n * array->icd.sz);
+        memcpy(result->d, array->d, array->n * array->icd.sz);
+    } else {
+        result->d = NULL;
+    }
 
     return result;
 }
@@ -44,6 +48,7 @@ static inline void *utarray_steal(UT_array *array)
     void *data = array->d;
     array->i   = 0;
     array->n   = 0;
+    array->d   = NULL;
     return data;
 }
 
@@ -75,4 +80,15 @@ static inline void *utarray_steal(UT_array *array)
     for ((el) = (head); (el) != NULL; (el) = DECLTYPE(el)((el)->hh.next))
 #endif
 
+static inline UT_array *utarray_deep_clone(UT_array *array)
+{
+    UT_array *result = NULL;
+
+    utarray_new(result, &array->icd);
+
+    utarray_foreach(array, void *, elem) { utarray_push_back(result, elem); }
+
+    return result;
+}
+
 #endif

plugins/ekuiper/plugin_ekuiper.c

@@ -316,6 +316,8 @@ static int ekuiper_plugin_request(neu_plugin_t *      plugin,
     case NEU_REQ_UPDATE_GROUP: {
         break;
     }
+    case NEU_REQ_DEL_GROUP:
+        break;
     case NEU_REQ_SUBSCRIBE_GROUP:
     case NEU_REQ_UPDATE_SUBSCRIBE_GROUP: {
         neu_req_subscribe_t *sub_info = data;
@@ -347,8 +349,8 @@ const neu_plugin_module_t neu_plugin_module = {
     .version         = NEURON_PLUGIN_VER_1_0,
     .schema          = "ekuiper",
     .module_name     = "eKuiper",
-    .module_descr    = "Neuron and LF Edge eKuiper integration plugin",
-    .module_descr_zh = "Neuron 和 LF Edge eKuiper 一体化插件",
+    .module_descr    = "LF Edge eKuiper integration plugin",
+    .module_descr_zh = "LF Edge eKuiper 一体化插件",
     .intf_funs       = &plugin_intf_funs,
     .kind            = NEU_PLUGIN_KIND_SYSTEM,
     .type            = NEU_NA_TYPE_APP,

plugins/ekuiper/read_write.c

@@ -123,9 +123,9 @@ int write_data(neu_plugin_t *plugin, json_write_req_t *write_req)
     header.ctx  = NULL;
     header.type = NEU_REQ_WRITE_TAG;
 
-    strcpy(cmd.driver, write_req->node_name);
-    strcpy(cmd.group, write_req->group_name);
-    strcpy(cmd.tag, write_req->tag_name);
+    cmd.driver = write_req->node_name;
+    cmd.group  = write_req->group_name;
+    cmd.tag    = write_req->tag_name;
 
     switch (write_req->t) {
     case NEU_JSON_INT:
@@ -156,5 +156,10 @@ int write_data(neu_plugin_t *plugin, json_write_req_t *write_req)
     }
 
     ret = neu_plugin_op(plugin, header, &cmd);
+    if (0 == ret) {
+        write_req->node_name  = NULL; // ownership moved
+        write_req->group_name = NULL; // ownership moved
+        write_req->tag_name   = NULL; // ownership moved
+    }
     return ret;
 }

plugins/monitor/monitor.c

@@ -402,7 +402,7 @@ static const neu_plugin_intf_funs_t plugin_intf_funs = {
 
 #define DEFAULT_MONITOR_PLUGIN_DESCR \
     "Builtin plugin for Neuron monitoring and alerting"
-#define DEFAULT_MONITOR_PLUGIN_DESCR_ZH "Neuron内置监控与告警插件"
+#define DEFAULT_MONITOR_PLUGIN_DESCR_ZH "内置监控与告警插件"
 
 const neu_plugin_module_t neu_plugin_module = {
     .version         = NEURON_PLUGIN_VER_1_0,

plugins/mqtt/mqtt_config.c

@@ -401,6 +401,7 @@ int mqtt_config_parse(neu_plugin_t *plugin, const char *setting,
 
 error:
     free(err_param);
+    free(client_id.v.val_str);
     free(write_req_topic.v.val_str);
     free(write_resp_topic.v.val_str);
     free(host.v.val_str);

plugins/mqtt/mqtt_handle.c

@@ -138,9 +138,13 @@ static inline int send_read_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
     header.ctx                = mqtt;
     header.type               = NEU_REQ_READ_GROUP;
     neu_req_read_group_t cmd  = { 0 };
-    strcpy(cmd.driver, req->node);
-    strcpy(cmd.group, req->group);
+    cmd.driver                = req->node;
+    cmd.group                 = req->group;
+    cmd.sync                  = req->sync;
+    req->node                 = NULL; // ownership moved
+    req->group                = NULL; // ownership moved
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
+        neu_req_read_group_fini(&cmd);
         plog_error(plugin, "neu_plugin_op(NEU_REQ_READ_GROUP) fail");
         return -1;
     }
@@ -148,6 +152,38 @@ static inline int send_read_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
     return 0;
 }
 
+static int json_value_to_tag_value(union neu_json_value *req,
+                                   enum neu_json_type t, neu_dvalue_t *value)
+{
+    switch (t) {
+    case NEU_JSON_INT:
+        value->type      = NEU_TYPE_INT64;
+        value->value.u64 = req->val_int;
+        break;
+    case NEU_JSON_STR:
+        value->type = NEU_TYPE_STRING;
+        strncpy(value->value.str, req->val_str, sizeof(value->value.str));
+        break;
+    case NEU_JSON_DOUBLE:
+        value->type      = NEU_TYPE_DOUBLE;
+        value->value.d64 = req->val_double;
+        break;
+    case NEU_JSON_BOOL:
+        value->type          = NEU_TYPE_BOOL;
+        value->value.boolean = req->val_bool;
+        break;
+    case NEU_JSON_BYTES:
+        value->type               = NEU_TYPE_BYTES;
+        value->value.bytes.length = req->val_bytes.length;
+        memcpy(value->value.bytes.bytes, req->val_bytes.bytes,
+               req->val_bytes.length);
+        break;
+    default:
+        return -1;
+    }
+    return 0;
+}
+
 static int send_write_tag_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
                               neu_json_write_req_t *req)
 {
@@ -160,34 +196,11 @@ static int send_write_tag_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
     header.ctx  = mqtt;
     header.type = NEU_REQ_WRITE_TAG;
 
-    strcpy(cmd.driver, req->node);
-    strcpy(cmd.group, req->group);
-    strcpy(cmd.tag, req->tag);
+    cmd.driver = req->node;
+    cmd.group  = req->group;
+    cmd.tag    = req->tag;
 
-    switch (req->t) {
-    case NEU_JSON_INT:
-        cmd.value.type      = NEU_TYPE_INT64;
-        cmd.value.value.u64 = req->value.val_int;
-        break;
-    case NEU_JSON_STR:
-        cmd.value.type = NEU_TYPE_STRING;
-        strcpy(cmd.value.value.str, req->value.val_str);
-        break;
-    case NEU_JSON_DOUBLE:
-        cmd.value.type      = NEU_TYPE_DOUBLE;
-        cmd.value.value.d64 = req->value.val_double;
-        break;
-    case NEU_JSON_BOOL:
-        cmd.value.type          = NEU_TYPE_BOOL;
-        cmd.value.value.boolean = req->value.val_bool;
-        break;
-    case NEU_JSON_BYTES:
-        cmd.value.type               = NEU_TYPE_BYTES;
-        cmd.value.value.bytes.length = req->value.val_bytes.length;
-        memcpy(cmd.value.value.bytes.bytes, req->value.val_bytes.bytes,
-               req->value.val_bytes.length);
-        break;
-    default:
+    if (0 != json_value_to_tag_value(&req->value, req->t, &cmd.value)) {
         plog_error(plugin, "invalid tag value type: %d", req->t);
         return -1;
     }
@@ -197,6 +210,9 @@ static int send_write_tag_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
         return -1;
     }
 
+    req->node  = NULL; // ownership moved
+    req->group = NULL; // ownership moved
+    req->tag   = NULL; // ownership moved
     return 0;
 }
 
@@ -220,42 +236,19 @@ static int send_write_tags_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
     };
 
     neu_req_write_tags_t cmd = { 0 };
-    strcpy(cmd.driver, req->node);
-    strcpy(cmd.group, req->group);
-    cmd.n_tag = req->n_tag;
-    cmd.tags  = calloc(cmd.n_tag, sizeof(neu_resp_tag_value_t));
+    cmd.driver               = req->node;
+    cmd.group                = req->group;
+    cmd.n_tag                = req->n_tag;
+    cmd.tags                 = calloc(cmd.n_tag, sizeof(neu_resp_tag_value_t));
     if (NULL == cmd.tags) {
         return -1;
     }
 
     for (int i = 0; i < cmd.n_tag; i++) {
         strcpy(cmd.tags[i].tag, req->tags[i].tag);
-        switch (req->tags[i].t) {
-        case NEU_JSON_INT:
-            cmd.tags[i].value.type      = NEU_TYPE_INT64;
-            cmd.tags[i].value.value.u64 = req->tags[i].value.val_int;
-            break;
-        case NEU_JSON_STR:
-            cmd.tags[i].value.type = NEU_TYPE_STRING;
-            strcpy(cmd.tags[i].value.value.str, req->tags[i].value.val_str);
-            break;
-        case NEU_JSON_DOUBLE:
-            cmd.tags[i].value.type      = NEU_TYPE_DOUBLE;
-            cmd.tags[i].value.value.d64 = req->tags[i].value.val_double;
-            break;
-        case NEU_JSON_BOOL:
-            cmd.tags[i].value.type          = NEU_TYPE_BOOL;
-            cmd.tags[i].value.value.boolean = req->tags[i].value.val_bool;
-            break;
-        case NEU_JSON_BYTES:
-            cmd.tags[i].value.type = NEU_TYPE_BYTES;
-            cmd.tags[i].value.value.bytes.length =
-                req->tags[i].value.val_bytes.length;
-            memcpy(cmd.tags[i].value.value.bytes.bytes,
-                   req->tags[i].value.val_bytes.bytes,
-                   req->tags[i].value.val_bytes.length);
-            break;
-        default:
+        if (0 !=
+            json_value_to_tag_value(&req->tags[i].value, req->tags[i].t,
+                                    &cmd.tags[i].value)) {
             plog_error(plugin, "invalid tag value type: %d", req->tags[i].t);
             free(cmd.tags);
             return -1;
@@ -268,6 +261,9 @@ static int send_write_tags_req(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt,
         return -1;
     }
 
+    req->node  = NULL; // ownership moved
+    req->group = NULL; // ownership moved
+
     return 0;
 }
 
@@ -480,7 +476,6 @@ int handle_read_response(neu_plugin_t *plugin, neu_json_mqtt_t *mqtt_json,
 
 end:
     neu_json_decode_mqtt_req_free(mqtt_json);
-    free(data->tags);
     return rv;
 }
 
@@ -606,6 +601,14 @@ int handle_unsubscribe_group(neu_plugin_t *         plugin,
     return 0;
 }
 
+int handle_del_group(neu_plugin_t *plugin, neu_req_del_group_t *req)
+{
+    route_tbl_del(&plugin->route_tbl, req->driver, req->group);
+    plog_notice(plugin, "del route driver:%s group:%s", req->driver,
+                req->group);
+    return 0;
+}
+
 int handle_update_group(neu_plugin_t *plugin, neu_req_update_group_t *req)
 {
     route_tbl_update_group(&plugin->route_tbl, req->driver, req->group,

plugins/mqtt/mqtt_handle.h

@@ -49,6 +49,7 @@ int handle_unsubscribe_group(neu_plugin_t *         plugin,
                              neu_req_unsubscribe_t *unsub_info);
 
 int handle_update_group(neu_plugin_t *plugin, neu_req_update_group_t *req);
+int handle_del_group(neu_plugin_t *plugin, neu_req_del_group_t *cmd);
 
 int handle_update_driver(neu_plugin_t *plugin, neu_req_update_node_t *req);
 int handle_del_driver(neu_plugin_t *plugin, neu_reqresp_node_deleted_t *req);

plugins/mqtt/mqtt_plugin.c

@@ -368,6 +368,9 @@ static int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
     case NEU_REQ_UPDATE_GROUP:
         error = handle_update_group(plugin, data);
         break;
+    case NEU_REQ_DEL_GROUP:
+        error = handle_del_group(plugin, data);
+        break;
     case NEU_REQ_UPDATE_NODE:
         error = handle_update_driver(plugin, data);
         break;
@@ -393,8 +396,8 @@ static const neu_plugin_intf_funs_t plugin_intf_funs = {
     .request = mqtt_plugin_request,
 };
 
-#define DESCRIPTION "Neuron northbound MQTT plugin bases on NanoSDK."
-#define DESCRIPTION_ZH "基于 NanoSDK 的 Neuron 北向应用 MQTT 插件"
+#define DESCRIPTION "Northbound MQTT plugin bases on NanoSDK."
+#define DESCRIPTION_ZH "基于 NanoSDK 的北向应用 MQTT 插件"
 
 const neu_plugin_module_t neu_plugin_module = {
     .version         = NEURON_PLUGIN_VER_1_0,

plugins/restful/adapter_handle.c

@@ -330,10 +330,11 @@ void handle_get_node_state_resp(nng_aio *aio, neu_resp_get_node_state_t *state)
     neu_json_get_node_state_resp_t res    = { 0 };
     char *                         result = NULL;
 
-    res.link      = state->state.link;
-    res.running   = state->state.running;
-    res.rtt       = state->rtt;
-    res.log_level = state->state.log_level;
+    res.link       = state->state.link;
+    res.running    = state->state.running;
+    res.rtt        = state->rtt;
+    res.log_level  = (char *) log_level_to_str(state->state.log_level);
+    res.core_level = (char *) log_level_to_str(state->core_level);
 
     neu_json_encode_by_fn(&res, neu_json_encode_get_node_state_resp, &result);
 
@@ -358,9 +359,12 @@ void handle_get_nodes_state_resp(nng_aio *                   aio,
         states_res.nodes[index].running = state->state.running;
         states_res.nodes[index].link    = state->state.link;
         states_res.nodes[index].rtt     = state->rtt;
-        states_res.nodes[index].log_level = state->state.log_level;
+        states_res.nodes[index].log_level =
+            (char *) log_level_to_str(state->state.log_level);
     }
 
+    states_res.core_level = (char *) log_level_to_str(states->core_level);
+
     neu_json_encode_by_fn(&states_res, neu_json_encode_get_nodes_state_resp,
                           &result);
 

plugins/restful/file_handle.c

@@ -1,191 +0,0 @@
-/**
- * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- **/
-
-#include <dirent.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
-#include <unistd.h>
-
-#include <nng/nng.h>
-#include <nng/supplemental/http/http.h>
-
-#include "define.h"
-#include "handle.h"
-#include "utils/http.h"
-
-#include "plugin.h"
-#include "utils/log.h"
-#include "json/neu_json_error.h"
-#include "json/neu_json_fn.h"
-
-#include "file_handle.h"
-#include "log_handle.h"
-#include "parser/neu_json_file.h"
-
-void handle_file_info(nng_aio *aio)
-{
-    char dir_path[128] = { 0 };
-
-    int            n_file      = 0;
-    struct dirent *files       = { 0 };
-    char *         f_name[256] = { 0 };
-    char           c_time[32]  = { 0 };
-    char           m_time[32]  = { 0 };
-
-    neu_json_get_file_list_resp_t file_resp = { 0 };
-    char *                        result    = NULL;
-
-    NEU_VALIDATE_JWT(aio);
-
-    if (neu_http_get_param_str(aio, "dir_path", dir_path, sizeof(dir_path)) <=
-        0) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, {
-            neu_http_response(aio, error_code.error, result_error);
-        });
-
-        return;
-    }
-
-    /*check whether the directory exists*/
-    if (0 != access(dir_path, F_OK)) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_NOT_EXIST, {
-            neu_http_response(aio, error_code.error, result_error);
-        });
-
-        return;
-    }
-
-    /*open directory*/
-    DIR *dir = opendir(dir_path);
-    if (dir == NULL) {
-        nlog_error("open a directory failed");
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_OPEN_FAILURE, {
-            neu_http_response(aio, error_code.error, result_error);
-        });
-
-        return;
-    }
-
-    /*read directory*/
-    while ((files = readdir(dir)) != NULL) {
-        if (strcmp(files->d_name, ".") == 0 ||
-            strcmp(files->d_name, "..") == 0) {
-            continue;
-        }
-
-        f_name[n_file] = files->d_name;
-        ++n_file;
-    }
-
-    /*handle response*/
-    file_resp.n_file = n_file;
-    file_resp.file = calloc(file_resp.n_file, sizeof(neu_json_get_file_resp_t));
-
-    for (int i = 0; i < file_resp.n_file; i++) {
-        char        file_path[512] = { 0 };
-        struct stat statbuf;
-
-        sprintf(file_path, "%s/%s", dir_path, f_name[i]);
-        stat(file_path, &statbuf);
-
-        strncpy(c_time, ctime(&statbuf.st_ctim.tv_sec),
-                strlen(ctime(&statbuf.st_ctim.tv_sec)) - 1);
-        strncpy(m_time, ctime(&statbuf.st_mtim.tv_sec),
-                strlen(ctime(&statbuf.st_mtim.tv_sec)) - 1);
-
-        file_resp.file[i].name  = f_name[i];
-        file_resp.file[i].size  = statbuf.st_size;
-        file_resp.file[i].ctime = c_time;
-        file_resp.file[i].mtime = m_time;
-    }
-
-    neu_json_encode_by_fn(&file_resp, neu_json_encode_get_file_list_resp,
-                          &result);
-
-    closedir(dir);
-    neu_http_ok(aio, result);
-    free(result);
-    free(file_resp.file);
-
-    return;
-}
-
-void handle_download_file(nng_aio *aio)
-{
-    char file_name[NEU_FILE_PATH_LEN] = { 0 };
-    char file_path[256]               = { 0 };
-    char http_resp[256]               = { 0 };
-
-    int    rv        = 0;
-    void * file_data = NULL;
-    size_t file_len  = 0;
-    char * p         = NULL;
-
-    NEU_VALIDATE_JWT(aio);
-
-    if (neu_http_get_param_str(aio, "file_path", file_path,
-                               sizeof(file_path)) <= 0) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, {
-            neu_http_response(aio, error_code.error, result_error);
-        });
-
-        return;
-    }
-
-    /*check whether the file exists*/
-    rv = access(file_path, F_OK);
-    if (0 != rv) {
-        NEU_JSON_RESPONSE_ERROR(NEU_ERR_FILE_NOT_EXIST, {
-            neu_http_response(aio, error_code.error, result_error);
-        });
-
-        return;
-    }
-
-    /*read file content*/
-    rv = read_file(file_path, &file_data, &file_len);
-    if (0 != rv) {
-        NEU_JSON_RESPONSE_ERROR(
-            rv, { neu_http_response(aio, error_code.error, result_error); });
-
-        return;
-    }
-
-    /*extract file name*/
-    p = strchr(file_path, '/');
-    while (strchr(p, '/') != NULL) {
-        p = strchr(p, '/') + 1;
-    }
-
-    if (p != NULL) {
-        strcpy(file_name, p);
-    }
-
-    /*handle http response*/
-    sprintf(http_resp, "%s%s", "attachment; filename=", file_name);
-    rv = neu_http_response_file(aio, file_data, file_len, http_resp);
-    free(file_data);
-    nlog_notice("download file %s, rv: %d", file_name, rv);
-}

plugins/restful/handle.c

@@ -26,7 +26,6 @@
 
 #include "adapter_handle.h"
 #include "datatag_handle.h"
-#include "file_handle.h"
 #include "global_config_handle.h"
 #include "group_config_handle.h"
 #include "log_handle.h"
@@ -78,6 +77,9 @@ static struct neu_http_handler cors_handler[] = {
     {
         .url = "/api/v2/write/tags",
     },
+    {
+        .url = "/api/v2/write/gtags",
+    },
     {
         .url = "/api/v2/subscribe",
     },
@@ -108,12 +110,6 @@ static struct neu_http_handler cors_handler[] = {
     {
         .url = "/api/v2/log/level",
     },
-    {
-        .url = "/api/v2/file",
-    },
-    {
-        .url = "/api/v2/file/info",
-    },
     {
         .url = "/api/v2/global/config",
     },
@@ -290,6 +286,12 @@ static struct neu_http_handler rest_handlers[] = {
         .url           = "/api/v2/write/tags",
         .value.handler = handle_write_tags,
     },
+    {
+        .method        = NEU_HTTP_METHOD_POST,
+        .type          = NEU_HTTP_HANDLER_FUNCTION,
+        .url           = "/api/v2/write/gtags",
+        .value.handler = handle_write_gtags,
+    },
     {
         .method        = NEU_HTTP_METHOD_POST,
         .type          = NEU_HTTP_HANDLER_FUNCTION,
@@ -368,18 +370,6 @@ static struct neu_http_handler rest_handlers[] = {
         .url           = "/api/v2/version",
         .value.handler = handle_get_version,
     },
-    {
-        .method        = NEU_HTTP_METHOD_GET,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .url           = "/api/v2/file",
-        .value.handler = handle_download_file,
-    },
-    {
-        .method        = NEU_HTTP_METHOD_GET,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .url           = "/api/v2/file/info",
-        .value.handler = handle_file_info,
-    },
     {
         .method        = NEU_HTTP_METHOD_GET,
         .type          = NEU_HTTP_HANDLER_FUNCTION,

plugins/restful/log_handle.c

@@ -113,78 +113,48 @@ void handle_log_level(nng_aio *aio)
     NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
         aio, neu_json_update_log_level_req_t,
         neu_json_decode_update_log_level_req, {
-            int                        ret    = 0;
-            neu_reqresp_head_t         header = { 0 };
-            neu_req_update_log_level_t cmd    = { 0 };
-            zlog_category_t *          ct = zlog_get_category(req->node_name);
-            zlog_category_t *          neuron = zlog_get_category("neuron");
-            int                        log_level;
-            static int                 log_level_neuron = 60;
+            neu_reqresp_head_t         header    = { 0 };
+            neu_req_update_log_level_t cmd       = { 0 };
+            int                        log_level = -1;
 
             if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_DEBUG)) {
                 log_level = ZLOG_LEVEL_DEBUG;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_DEBUG);
             } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_INFO)) {
                 log_level = ZLOG_LEVEL_INFO;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_INFO);
             } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_NOTICE)) {
                 log_level = ZLOG_LEVEL_NOTICE;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_NOTICE);
             } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_WARN)) {
                 log_level = ZLOG_LEVEL_WARN;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_WARN);
             } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_ERROR)) {
                 log_level = ZLOG_LEVEL_ERROR;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_ERROR);
             } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_FATAL)) {
                 log_level = ZLOG_LEVEL_FATAL;
-                strcpy(cmd.log_level, NEU_LOG_LEVEL_FATAL);
             } else {
-                strcpy(cmd.log_level, "unknow");
-                nlog_error(
-                    "Failed to modify log_level of the node, node_name:%s, ",
-                    req->node_name);
+                nlog_error("Failed to modify log_level of the node, "
+                           "node_name:%s, log_level: %s",
+                           req->node_name, req->log_level);
+            }
+
+            if (log_level == -1) {
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, {
                     neu_http_response(aio, error_code.error, result_error);
                 });
-                goto end;
-            }
+            } else {
+                header.ctx    = aio;
+                header.type   = NEU_REQ_UPDATE_LOG_LEVEL;
+                cmd.core      = req->core;
+                cmd.log_level = log_level;
+                if (req->node_name != NULL) {
+                    strcpy(cmd.node, req->node_name);
+                }
 
-            ret = zlog_level_switch(ct, log_level);
-            if (ret != 0) {
-                nlog_error(
-                    "Failed to modify log_level of the node, node_name:%s, "
-                    "ret: %d,",
-                    req->node_name, ret);
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
+                int ret = neu_plugin_op(plugin, header, &cmd);
+                if (ret != 0) {
+                    NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
+                        neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
+                    });
+                }
             }
-
-            if (log_level > log_level_neuron) {
-                log_level_neuron = log_level;
-            }
-
-            ret = zlog_level_switch(neuron, log_level_neuron);
-            if (ret != 0) {
-                nlog_error("Failed to modify log_level of the node, ret: %d",
-                           ret);
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
-                    neu_http_response(aio, error_code.error, result_error);
-                });
-            }
-
-            header.ctx  = aio;
-            header.type = NEU_REQ_UPDATE_LOG_LEVEL;
-            strcpy(cmd.node, req->node_name);
-
-            ret = neu_plugin_op(plugin, header, &cmd);
-            if (ret != 0) {
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
-                    neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
-                });
-            }
-        end:;
         })
 }
 

plugins/restful/normal_handle.c

@@ -58,7 +58,7 @@ void handle_login(nng_aio *aio)
 
             if (NULL == user) {
                 nlog_error("could not find user `%s`", req->name);
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_INVALID_USER, {
+                NEU_JSON_RESPONSE_ERROR(NEU_ERR_INVALID_USER_OR_PASSWORD, {
                     neu_http_response(aio, error_code.error, result_error);
                 });
             } else if (pass_len < NEU_USER_PASSWORD_MIN_LEN ||
@@ -90,7 +90,7 @@ void handle_login(nng_aio *aio)
                 free(result);
             } else {
                 nlog_error("user `%s` password check fail", req->name);
-                NEU_JSON_RESPONSE_ERROR(NEU_ERR_INVALID_PASSWORD, {
+                NEU_JSON_RESPONSE_ERROR(NEU_ERR_INVALID_USER_OR_PASSWORD, {
                     neu_http_response(aio, error_code.error, result_error);
                 });
             }
@@ -114,10 +114,10 @@ void handle_password(nng_aio *aio)
                 rv = NEU_ERR_INVALID_PASSWORD_LEN;
             } else if (NULL == (user = neu_load_user(req->name))) {
                 nlog_error("could not find user `%s`", req->name);
-                rv = NEU_ERR_INVALID_USER;
+                rv = NEU_ERR_INVALID_USER_OR_PASSWORD;
             } else if (!neu_user_check_password(user, req->old_pass)) {
                 nlog_error("user `%s` password check fail", req->name);
-                rv = NEU_ERR_INVALID_PASSWORD;
+                rv = NEU_ERR_INVALID_USER_OR_PASSWORD;
             } else if (0 !=
                        (rv = neu_user_update_password(user, req->new_pass))) {
                 nlog_error("user `%s` update password fail", req->name);

plugins/restful/rw_handle.c

@@ -41,10 +41,14 @@ void handle_read(nng_aio *aio)
             header.ctx  = aio;
             header.type = NEU_REQ_READ_GROUP;
 
-            strcpy(cmd.driver, req->node);
-            strcpy(cmd.group, req->group);
-            ret = neu_plugin_op(plugin, header, &cmd);
+            cmd.driver = req->node;
+            cmd.group  = req->group;
+            cmd.sync   = req->sync;
+            req->node  = NULL;
+            req->group = NULL;
+            ret        = neu_plugin_op(plugin, header, &cmd);
             if (ret != 0) {
+                neu_req_read_group_fini(&cmd);
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
                     neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
                 });
@@ -86,9 +90,12 @@ void handle_write(nng_aio *aio)
             header.ctx  = aio;
             header.type = NEU_REQ_WRITE_TAG;
 
-            strcpy(cmd.driver, req->node);
-            strcpy(cmd.group, req->group);
-            strcpy(cmd.tag, req->tag);
+            cmd.driver = req->node;
+            cmd.group  = req->group;
+            cmd.tag    = req->tag;
+            req->node  = NULL; // ownership moved
+            req->group = NULL; // ownership moved
+            req->tag   = NULL; // ownership moved
 
             switch (req->t) {
             case NEU_JSON_INT:
@@ -120,6 +127,7 @@ void handle_write(nng_aio *aio)
 
             int ret = neu_plugin_op(plugin, header, &cmd);
             if (ret != 0) {
+                neu_req_write_tag_fini(&cmd);
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
                     neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
                 });
@@ -154,17 +162,19 @@ void handle_write_tags(nng_aio *aio)
             header.ctx  = aio;
             header.type = NEU_REQ_WRITE_TAGS;
 
-            strcpy(cmd.driver, req->node);
-            strcpy(cmd.group, req->group);
-            cmd.n_tag = req->n_tag;
-            cmd.tags  = calloc(cmd.n_tag, sizeof(neu_resp_tag_value_t));
+            cmd.driver = req->node;
+            cmd.group  = req->group;
+            cmd.n_tag  = req->n_tag;
+            cmd.tags   = calloc(cmd.n_tag, sizeof(neu_resp_tag_value_t));
+            req->node  = NULL; // ownership moved
+            req->group = NULL; // ownership moved
 
             for (int i = 0; i < cmd.n_tag; i++) {
                 strcpy(cmd.tags[i].tag, req->tags[i].tag);
                 switch (req->tags[i].t) {
                 case NEU_JSON_INT:
                     cmd.tags[i].value.type      = NEU_TYPE_INT64;
-                    cmd.tags[i].value.value.u64 = req->tags[i].value.val_int;
+                    cmd.tags[i].value.value.i64 = req->tags[i].value.val_int;
                     break;
                 case NEU_JSON_STR:
                     cmd.tags[i].value.type = NEU_TYPE_STRING;
@@ -196,6 +206,87 @@ void handle_write_tags(nng_aio *aio)
 
             int ret = neu_plugin_op(plugin, header, &cmd);
             if (ret != 0) {
+                neu_req_write_tags_fini(&cmd);
+                NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
+                    neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
+                });
+            }
+        })
+}
+
+static void trans(neu_json_write_gtags_req_t *req, neu_req_write_gtags_t *cmd)
+{
+    cmd->driver  = req->node;
+    req->node    = NULL; // ownership moved
+    cmd->n_group = req->n_group;
+    cmd->groups  = calloc(cmd->n_group, sizeof(neu_req_gtag_group_t));
+    for (int i = 0; i < cmd->n_group; i++) {
+        cmd->groups[i].group = req->groups[i].group;
+        req->groups[i].group = NULL; // ownership moved
+        cmd->groups[i].n_tag = req->groups[i].n_tag;
+        cmd->groups[i].tags =
+            calloc(cmd->groups[i].n_tag, sizeof(neu_resp_tag_value_t));
+
+        for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+            strcpy(cmd->groups[i].tags[k].tag, req->groups[i].tags[k].tag);
+
+            switch (req->groups[i].tags[k].t) {
+            case NEU_JSON_INT:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_INT64;
+                cmd->groups[i].tags[k].value.value.u64 =
+                    req->groups[i].tags[k].value.val_int;
+                break;
+            case NEU_JSON_STR:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_STRING;
+                strcpy(cmd->groups[i].tags[k].value.value.str,
+                       req->groups[i].tags[k].value.val_str);
+                break;
+            case NEU_JSON_DOUBLE:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_DOUBLE;
+                cmd->groups[i].tags[k].value.value.d64 =
+                    req->groups[i].tags[k].value.val_double;
+                break;
+            case NEU_JSON_BOOL:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_BOOL;
+                cmd->groups[i].tags[k].value.value.boolean =
+                    req->groups[i].tags[k].value.val_bool;
+                break;
+            case NEU_JSON_BYTES:
+                cmd->groups[i].tags[k].value.type = NEU_TYPE_BYTES;
+                cmd->groups[i].tags[k].value.value.bytes.length =
+                    req->groups[i].tags[k].value.val_bytes.length;
+                memcpy(cmd->groups[i].tags[k].value.value.bytes.bytes,
+                       req->groups[i].tags[k].value.val_bytes.bytes,
+                       req->groups[i].tags[k].value.val_bytes.length);
+                break;
+            default:
+                assert(false);
+                break;
+            }
+        }
+    }
+}
+
+void handle_write_gtags(nng_aio *aio)
+{
+    neu_plugin_t *plugin = neu_rest_get_plugin();
+
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
+        aio, neu_json_write_gtags_req_t, neu_json_decode_write_gtags_req, {
+            neu_reqresp_head_t    header = { 0 };
+            neu_req_write_gtags_t cmd    = { 0 };
+
+            nng_http_req *nng_req = nng_aio_get_input(aio, 0);
+            nlog_notice("<%p> req %s %s", aio, nng_http_req_get_method(nng_req),
+                        nng_http_req_get_uri(nng_req));
+            header.ctx  = aio;
+            header.type = NEU_REQ_WRITE_GTAGS;
+
+            trans(req, &cmd);
+
+            int ret = neu_plugin_op(plugin, header, &cmd);
+            if (ret != 0) {
+                neu_req_write_gtags_fini(&cmd);
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, {
                     neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
                 });

plugins/restful/rw_handle.h

@@ -29,6 +29,7 @@ void handle_rw_uninit();
 void handle_read(nng_aio *aio);
 void handle_write(nng_aio *aio);
 void handle_write_tags(nng_aio *aio);
+void handle_write_gtags(nng_aio *aio);
 void handle_read_resp(nng_aio *aio, neu_resp_read_group_t *resp);
 
 #endif

src/adapter/adapter.c

@@ -31,17 +31,19 @@
 
 #include "adapter.h"
 #include "adapter_internal.h"
+#include "base/msg_internal.h"
 #include "driver/driver_internal.h"
 #include "errcodes.h"
 #include "persist/persist.h"
 #include "plugin.h"
 #include "storage.h"
 
-static int adapter_trans_data(enum neu_event_io_type type, int fd,
-                              void *usr_data);
-static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data);
-static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
-                           void *data);
+static void *adapter_consumer(void *arg);
+static int   adapter_trans_data(enum neu_event_io_type type, int fd,
+                                void *usr_data);
+static int   adapter_loop(enum neu_event_io_type type, int fd, void *usr_data);
+static int   adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
+                             void *data);
 static int adapter_response(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                             void *data);
 static int adapter_responseto(neu_adapter_t *     adapter,
@@ -103,6 +105,36 @@ void neu_adapter_set_error(int error)
     create_adapter_error = error;
 }
 
+static void *adapter_consumer(void *arg)
+{
+    neu_adapter_t *adapter = (neu_adapter_t *) arg;
+    while (1) {
+        neu_msg_t *         msg    = NULL;
+        uint32_t            n      = adapter_msg_q_pop(adapter->msg_q, &msg);
+        neu_reqresp_head_t *header = neu_msg_get_header(msg);
+
+        nlog_debug("adapter(%s) recv msg from: %s %p, type: %s, %u",
+                   adapter->name, header->sender, header->ctx,
+                   neu_reqresp_type_string(header->type), n);
+        adapter->module->intf_funs->request(
+            adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
+        neu_msg_free(msg);
+    }
+
+    return NULL;
+}
+
+static inline zlog_category_t *get_log_category(const char *node)
+{
+    char name[NEU_NODE_NAME_LEN] = { 0 };
+    // replace path separators
+    for (int i = 0; node[i]; ++i) {
+        name[i] = ('/' == node[i] || '\\' == node[i]) ? '_' : node[i];
+    }
+    return zlog_get_category(name);
+}
+
 neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
 {
     int                  rv      = 0;
@@ -146,6 +178,7 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
     adapter->module                  = info->module;
     adapter->timestamp_lev           = 0;
     adapter->trans_data_port         = 0;
+    adapter->log_level               = ZLOG_LEVEL_NOTICE;
 
     struct sockaddr_in remote = {
         .sin_family      = AF_INET,
@@ -165,6 +198,9 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
         break;
     case NEU_NA_TYPE_NDRIVER:
     case NEU_NA_TYPE_APP: {
+        adapter->msg_q = adapter_msg_q_new(adapter->name, 1024);
+        pthread_create(&adapter->consumer_tid, NULL, adapter_consumer,
+                       (void *) adapter);
         while (true) {
             uint16_t           port  = neu_manager_get_port();
             struct sockaddr_in local = {
@@ -200,7 +236,7 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
     common->adapter             = adapter;
     common->adapter_callbacks   = &adapter->cb_funs;
     common->link_state          = NEU_NODE_LINK_STATE_DISCONNECTED;
-    common->log                 = zlog_get_category(adapter->name);
+    common->log                 = get_log_category(adapter->name);
     strcpy(common->name, adapter->name);
 
     zlog_level_switch(common->log, default_log_level);
@@ -261,7 +297,7 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
         return NEU_ERR_EINTERNAL;
     }
 
-    zlog_category_t *log = zlog_get_category(name);
+    zlog_category_t *log = get_log_category(name);
     if (NULL == log) {
         free(name);
         free(old_name);
@@ -301,23 +337,24 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
 
 void neu_adapter_init(neu_adapter_t *adapter, neu_node_running_state_e state)
 {
-    memset(adapter->buf, 0, sizeof(adapter->buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->buf;
-    neu_req_node_init_t init   = { 0 };
-
-    header->type = NEU_REQ_NODE_INIT;
+    neu_req_node_init_t init = { 0 };
+    init.state               = state;
+    strcpy(init.node, adapter->name);
 
+    neu_msg_t *msg = neu_msg_new(NEU_REQ_NODE_INIT, NULL, &init);
+    if (NULL == msg) {
+        nlog_error("failed alloc msg for %s", adapter->name);
+        return;
+    }
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
     strcpy(header->sender, adapter->name);
     strcpy(header->receiver, "manager");
-    strcpy(init.node, adapter->name);
-    init.state = state;
 
-    neu_msg_gen(header, &init);
-
-    int ret = send(adapter->control_fd, header, header->len, 0);
-    if (ret != (int) header->len) {
+    int ret = neu_send_msg(adapter->control_fd, msg);
+    if (0 != ret) {
         nlog_error("%s failed to send init msg to manager, ret: %d, errno: %d",
                    adapter->name, ret, errno);
+        neu_msg_free(msg);
     }
 }
 
@@ -406,21 +443,36 @@ static void adapter_reset_metrics(neu_adapter_t *adapter)
 static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
                            void *data)
 {
-    int     ret                   = 0;
-    uint8_t buf[NEU_MSG_MAX_SIZE] = { 0 };
+    int ret = 0;
 
-    neu_reqresp_head_t *pheader = (neu_reqresp_head_t *) buf;
-    *pheader                    = header;
+    neu_msg_t *msg = neu_msg_new(header.type, header.ctx, data);
+    if (NULL == msg) {
+        return NEU_ERR_EINTERNAL;
+    }
+    neu_reqresp_head_t *pheader = neu_msg_get_header(msg);
 
     strcpy(pheader->sender, adapter->name);
     switch (pheader->type) {
-    case NEU_REQ_READ_GROUP:
-    case NEU_REQ_WRITE_TAGS:
-    case NEU_REQ_WRITE_TAG: {
+    case NEU_REQ_READ_GROUP: {
         neu_req_read_group_t *cmd = (neu_req_read_group_t *) data;
         strcpy(pheader->receiver, cmd->driver);
         break;
     }
+    case NEU_REQ_WRITE_TAG: {
+        neu_req_write_tag_t *cmd = (neu_req_write_tag_t *) data;
+        strcpy(pheader->receiver, cmd->driver);
+        break;
+    }
+    case NEU_REQ_WRITE_TAGS: {
+        neu_req_write_tags_t *cmd = (neu_req_write_tags_t *) data;
+        strcpy(pheader->receiver, cmd->driver);
+        break;
+    }
+    case NEU_REQ_WRITE_GTAGS: {
+        neu_req_write_gtags_t *cmd = (neu_req_write_gtags_t *) data;
+        strcpy(pheader->receiver, cmd->driver);
+        break;
+    }
     case NEU_REQ_DEL_NODE: {
         neu_req_del_node_t *cmd = (neu_req_del_node_t *) data;
         strcpy(pheader->receiver, cmd->node);
@@ -477,15 +529,14 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
         break;
     }
 
-    neu_msg_gen(pheader, data);
-
-    ret = send(adapter->control_fd, pheader, pheader->len, 0);
-    if (ret != (int) pheader->len) {
+    ret = neu_send_msg(adapter->control_fd, msg);
+    if (0 != ret) {
         nlog_error(
             "adapter: %s send %d command %s failed, ret: %d-%d, errno: %s(%d)",
             adapter->name, adapter->control_fd,
             neu_reqresp_type_string(pheader->type), ret, pheader->len,
             strerror(errno), errno);
+        neu_msg_free(msg);
         return -1;
     } else {
         return 0;
@@ -499,11 +550,13 @@ static int adapter_response(neu_adapter_t *adapter, neu_reqresp_head_t *header,
     neu_msg_exchange(header);
 
     neu_msg_gen(header, data);
-    int ret = send(adapter->control_fd, header, header->len, 0);
-    if (ret <= 0) {
+    neu_msg_t *msg = (neu_msg_t *) header;
+    int        ret = neu_send_msg(adapter->control_fd, msg);
+    if (0 != ret) {
         nlog_error("adapter: %s send response %s failed, ret: %d, errno: %d",
                    adapter->name, neu_reqresp_type_string(header->type), ret,
                    errno);
+        neu_msg_free(msg);
     }
 
     return ret;
@@ -514,15 +567,20 @@ static int adapter_responseto(neu_adapter_t *     adapter,
                               struct sockaddr_in dst)
 {
     assert(header->type == NEU_REQRESP_TRANS_DATA);
-    strcpy(header->sender, adapter->name);
 
-    neu_msg_gen(header, data);
-    int ret = sendto(adapter->control_fd, header, header->len, 0,
-                     (struct sockaddr *) &dst, sizeof(dst));
-    if (ret <= 0) {
+    neu_msg_t *msg = neu_msg_new(header->type, header->ctx, data);
+    if (NULL == msg) {
+        return NEU_ERR_EINTERNAL;
+    }
+    neu_reqresp_head_t *pheader = neu_msg_get_header(msg);
+    strcpy(pheader->sender, adapter->name);
+
+    int ret = neu_send_msg_to(adapter->control_fd, &dst, msg);
+    if (0 != ret) {
         nlog_error("adapter: %s send responseto %s failed, ret: %d, errno: %d",
                    adapter->name, neu_reqresp_type_string(header->type), ret,
                    errno);
+        neu_msg_free(msg);
     }
 
     return ret;
@@ -538,17 +596,16 @@ static int adapter_trans_data(enum neu_event_io_type type, int fd,
         return 0;
     }
 
-    memset(adapter->recv_buf, 0, sizeof(adapter->recv_buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->recv_buf;
-
-    int rv = recv(adapter->trans_data_fd, adapter->recv_buf,
-                  sizeof(adapter->recv_buf), 0);
-    if (rv <= 0) {
+    neu_msg_t *msg = NULL;
+    int        rv  = neu_recv_msg(adapter->trans_data_fd, &msg);
+    if (0 != rv) {
         nlog_warn("adapter: %s recv trans data failed, ret: %d, errno: %s(%d)",
                   adapter->name, rv, strerror(errno), errno);
         return 0;
     }
 
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
+
     nlog_debug("adapter(%s) recv msg from: %s %p, type: %s", adapter->name,
                header->sender, header->ctx,
                neu_reqresp_type_string(header->type));
@@ -557,37 +614,46 @@ static int adapter_trans_data(enum neu_event_io_type type, int fd,
         header->type != NEU_RESP_ERROR) {
         nlog_warn("adapter: %s recv msg type error, type: %s", adapter->name,
                   neu_reqresp_type_string(header->type));
+        neu_msg_free(msg);
+        return 0;
+    }
+
+    if (header->type == NEU_REQRESP_TRANS_DATA) {
+        if (adapter_msg_q_push(adapter->msg_q, msg) < 0) {
+            nlog_warn("adapter: %s trans data msg q is full, drop msg",
+                      adapter->name);
+            neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
+            neu_msg_free(msg);
+        }
         return 0;
     }
 
     adapter->module->intf_funs->request(
         adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
-    if (header->type == NEU_REQRESP_TRANS_DATA) {
-        neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
-    }
+    neu_msg_free(msg);
     return 0;
 }
 
 static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
 {
     neu_adapter_t *adapter = (neu_adapter_t *) usr_data;
+
     if (type != NEU_EVENT_IO_READ) {
         nlog_warn("adapter: %s recv close, exit loop, fd: %d", adapter->name,
                   fd);
         return 0;
     }
 
-    memset(adapter->recv_buf, 0, sizeof(adapter->recv_buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->recv_buf;
-
-    int rv = recv(adapter->control_fd, adapter->recv_buf,
-                  sizeof(adapter->recv_buf), 0);
-    if (rv <= 0) {
+    neu_msg_t *msg = NULL;
+    int        rv  = neu_recv_msg(adapter->control_fd, &msg);
+    if (0 != rv) {
         nlog_warn("adapter: %s recv failed, ret: %d, errno: %s(%d)",
                   adapter->name, rv, strerror(errno), errno);
         return 0;
     }
 
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
+
     nlog_info("adapter(%s) recv msg from: %s %p, type: %s", adapter->name,
               header->sender, header->ctx,
               neu_reqresp_type_string(header->type));
@@ -601,6 +667,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             adapter->module->intf_funs->request(
                 adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
         }
+        neu_msg_free(msg);
         break;
     }
     case NEU_REQ_UNSUBSCRIBE_GROUP: {
@@ -612,6 +679,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             adapter->module->intf_funs->request(
                 adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
         }
+        neu_msg_free(msg);
         break;
     }
     case NEU_REQ_UPDATE_SUBSCRIBE_GROUP:
@@ -651,11 +719,13 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_UPDATE_TAG_EVENT:
         adapter->module->intf_funs->request(
             adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        neu_msg_free(msg);
         break;
     case NEU_RESP_READ_GROUP:
         adapter->module->intf_funs->request(
             adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
         neu_resp_read_free((neu_resp_read_group_t *) &header[1]);
+        neu_msg_free(msg);
         break;
     case NEU_REQ_READ_GROUP: {
         neu_resp_error_t error = { 0 };
@@ -664,6 +734,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_adapter_driver_read_group((neu_adapter_driver_t *) adapter,
                                           header);
         } else {
+            neu_req_read_group_fini((neu_req_read_group_t *) &header[1]);
             error.error  = NEU_ERR_GROUP_NOT_ALLOW;
             header->type = NEU_RESP_ERROR;
             neu_msg_exchange(header);
@@ -676,11 +747,10 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_error_t error = { 0 };
 
         if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
-            void *msg_dump = calloc(header->len, 1);
-            memcpy(msg_dump, header, header->len);
             neu_adapter_driver_write_tag((neu_adapter_driver_t *) adapter,
-                                         msg_dump);
+                                         header);
         } else {
+            neu_req_write_tag_fini((neu_req_write_tag_t *) &header[1]);
             error.error  = NEU_ERR_GROUP_NOT_ALLOW;
             header->type = NEU_RESP_ERROR;
             neu_msg_exchange(header);
@@ -693,15 +763,29 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_error_t error = { 0 };
 
         if (adapter->module->type != NEU_NA_TYPE_DRIVER) {
+            neu_req_write_tags_fini((neu_req_write_tags_t *) &header[1]);
             error.error  = NEU_ERR_GROUP_NOT_ALLOW;
             header->type = NEU_RESP_ERROR;
             neu_msg_exchange(header);
             reply(adapter, header, &error);
         } else {
-            void *msg_dump = calloc(header->len, 1);
-            memcpy(msg_dump, header, header->len);
             neu_adapter_driver_write_tags((neu_adapter_driver_t *) adapter,
-                                          msg_dump);
+                                          header);
+        }
+        break;
+    }
+    case NEU_REQ_WRITE_GTAGS: {
+        neu_resp_error_t error = { 0 };
+
+        if (adapter->module->type != NEU_NA_TYPE_DRIVER) {
+            neu_req_write_gtags_fini((neu_req_write_gtags_t *) &header[1]);
+            error.error  = NEU_ERR_GROUP_NOT_ALLOW;
+            header->type = NEU_RESP_ERROR;
+            neu_msg_exchange(header);
+            reply(adapter, header, &error);
+        } else {
+            neu_adapter_driver_write_gtags((neu_adapter_driver_t *) adapter,
+                                           header);
         }
         break;
     }
@@ -737,21 +821,21 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             strcpy(resp.node, adapter->name);
             reply(adapter, header, &resp);
         }
-
         break;
     }
     case NEU_REQ_GET_NODE_STATE: {
-        neu_resp_get_node_state_t resp = { 0 };
+        neu_resp_get_node_state_t *resp =
+            (neu_resp_get_node_state_t *) &header[1];
 
         neu_metric_entry_t *e = NULL;
         if (NULL != adapter->metrics) {
             HASH_FIND_STR(adapter->metrics->entries, NEU_METRIC_LAST_RTT_MS, e);
         }
-        resp.rtt     = NULL != e ? e->value : 0;
-        resp.state   = neu_adapter_get_state(adapter);
+        resp->rtt    = NULL != e ? e->value : 0;
+        resp->state  = neu_adapter_get_state(adapter);
         header->type = NEU_RESP_GET_NODE_STATE;
         neu_msg_exchange(header);
-        reply(adapter, header, &resp);
+        reply(adapter, header, resp);
         break;
     }
     case NEU_REQ_GET_GROUP: {
@@ -857,7 +941,10 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             error.error = neu_adapter_driver_del_group(
                 (neu_adapter_driver_t *) adapter, cmd->group);
         } else {
-            error.error = NEU_ERR_GROUP_NOT_ALLOW;
+            adapter->module->intf_funs->request(
+                adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+            neu_msg_free(msg);
+            break;
         }
 
         if (error.error == NEU_ERR_SUCCESS) {
@@ -1051,19 +1138,22 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         strcpy(name, adapter->name);
         strcpy(receiver, header->receiver);
 
-        int ret = send(adapter->control_fd, header, header->len, 0);
-        if (ret != (int) header->len) {
+        int ret = neu_send_msg(adapter->control_fd, msg);
+        if (0 != ret) {
             nlog_error("%s %d send uninit msg to %s error: %s(%d)", name,
                        adapter->control_fd, receiver, strerror(errno), errno);
+            neu_msg_free(msg);
         } else {
             nlog_notice("%s send uninit msg to %s failed", name, receiver);
         }
         break;
     }
     case NEU_REQ_ADD_NDRIVER_MAP: {
+        neu_msg_free(msg);
         break;
     }
     case NEU_REQ_DEL_NDRIVER_MAP: {
+        neu_msg_free(msg);
         break;
     }
     case NEU_REQ_UPDATE_NDRIVER_TAG_PARAM: {
@@ -1123,8 +1213,13 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_UPDATE_LOG_LEVEL: {
+        neu_req_update_log_level_t *cmd =
+            (neu_req_update_log_level_t *) &header[1];
         neu_resp_error_t error = { 0 };
 
+        adapter->log_level = cmd->log_level;
+        zlog_level_switch(neu_plugin_to_plugin_common(adapter->plugin)->log,
+                          cmd->log_level);
         neu_msg_exchange(header);
         header->type = NEU_RESP_ERROR;
         reply(adapter, header, &error);
@@ -1160,6 +1255,13 @@ void neu_adapter_destroy(neu_adapter_t *adapter)
         neu_node_metrics_free(adapter->metrics);
     }
 
+    if (adapter->consumer_tid != 0) {
+        pthread_cancel(adapter->consumer_tid);
+    }
+    if (adapter->msg_q != NULL) {
+        adapter_msg_q_free(adapter->msg_q);
+    }
+
     char *setting = NULL;
     if (adapter_load_setting(adapter->name, &setting) != 0) {
         remove_logs(adapter->name);
@@ -1304,9 +1406,9 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter)
     neu_node_state_t     state  = { 0 };
     neu_plugin_common_t *common = neu_plugin_to_plugin_common(adapter->plugin);
 
-    state.link    = common->link_state;
-    state.running = adapter->state;
-    strcpy(state.log_level, common->log_level);
+    state.link      = common->link_state;
+    state.running   = adapter->state;
+    state.log_level = adapter->log_level;
 
     return state;
 }
@@ -1448,9 +1550,8 @@ inline static void reply(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                          void *data)
 {
     neu_msg_gen(header, data);
-
-    int ret = send(adapter->control_fd, header, header->len, 0);
-    if (ret <= 0) {
+    int ret = neu_send_msg(adapter->control_fd, (neu_msg_t *) header);
+    if (0 != ret) {
         nlog_warn("%s reply %s to %s, error: %s(%d)", header->sender,
                   neu_reqresp_type_string(header->type), header->receiver,
                   strerror(errno), errno);
@@ -1460,268 +1561,20 @@ inline static void reply(neu_adapter_t *adapter, neu_reqresp_head_t *header,
 inline static void notify_monitor(neu_adapter_t *    adapter,
                                   neu_reqresp_type_e event, void *data)
 {
-    memset(adapter->buf, 0, sizeof(adapter->buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->buf;
+    neu_msg_t *msg = neu_msg_new(event, NULL, data);
+    if (NULL == msg) {
+        return;
+    }
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
 
     strcpy(header->receiver, "manager");
     strncpy(header->sender, adapter->name, NEU_NODE_NAME_LEN);
-    header->type = event;
 
-    neu_msg_gen(header, data);
-
-    int ret = send(adapter->control_fd, header, header->len, 0);
-    if (ret <= 0) {
+    int ret = neu_send_msg(adapter->control_fd, msg);
+    if (0 != ret) {
         nlog_warn("notify %s of %s, error: %s(%d)", header->receiver,
                   neu_reqresp_type_string(header->type), strerror(errno),
                   errno);
+        neu_msg_free(msg);
     }
 }
-
-void neu_msg_gen(neu_reqresp_head_t *header, void *data)
-{
-    size_t data_size = 0;
-
-    switch (header->type) {
-    case NEU_REQRESP_TRANS_DATA:
-        data_size = sizeof(neu_reqresp_trans_data_t);
-        break;
-    case NEU_REQ_NODE_INIT:
-    case NEU_REQ_NODE_UNINIT:
-    case NEU_RESP_NODE_UNINIT:
-        data_size = sizeof(neu_req_node_init_t);
-        break;
-    case NEU_RESP_ERROR:
-        data_size = sizeof(neu_resp_error_t);
-        break;
-    case NEU_REQ_ADD_PLUGIN:
-        data_size = sizeof(neu_req_add_plugin_t);
-        break;
-    case NEU_REQ_DEL_PLUGIN:
-        data_size = sizeof(neu_req_del_plugin_t);
-        break;
-    case NEU_REQ_GET_PLUGIN:
-        data_size = sizeof(neu_req_get_plugin_t);
-        break;
-    case NEU_RESP_GET_PLUGIN:
-        data_size = sizeof(neu_resp_get_plugin_t);
-        break;
-    case NEU_REQ_ADD_TEMPLATE:
-        data_size = sizeof(neu_req_add_template_t);
-        break;
-    case NEU_REQ_DEL_TEMPLATE:
-        data_size = sizeof(neu_req_del_template_t);
-        break;
-    case NEU_REQ_GET_TEMPLATE:
-        data_size = sizeof(neu_req_get_template_t);
-        break;
-    case NEU_RESP_GET_TEMPLATE:
-        data_size = sizeof(neu_resp_get_template_t);
-        break;
-    case NEU_REQ_GET_TEMPLATES:
-        data_size = sizeof(neu_req_get_templates_t);
-        break;
-    case NEU_RESP_GET_TEMPLATES:
-        data_size = sizeof(neu_resp_get_templates_t);
-        break;
-    case NEU_REQ_ADD_TEMPLATE_GROUP:
-        data_size = sizeof(neu_req_add_template_group_t);
-        break;
-    case NEU_REQ_DEL_TEMPLATE_GROUP:
-        data_size = sizeof(neu_req_del_template_group_t);
-        break;
-    case NEU_REQ_UPDATE_TEMPLATE_GROUP:
-        data_size = sizeof(neu_req_update_template_group_t);
-        break;
-    case NEU_REQ_GET_TEMPLATE_GROUP:
-        data_size = sizeof(neu_req_get_template_group_t);
-        break;
-    case NEU_REQ_ADD_TEMPLATE_TAG:
-        data_size = sizeof(neu_req_add_template_tag_t);
-        break;
-    case NEU_REQ_DEL_TEMPLATE_TAG:
-        data_size = sizeof(neu_req_del_template_tag_t);
-        break;
-    case NEU_REQ_UPDATE_TEMPLATE_TAG:
-        data_size = sizeof(neu_req_update_template_tag_t);
-        break;
-    case NEU_REQ_GET_TEMPLATE_TAG:
-        data_size = sizeof(neu_req_get_template_tag_t);
-        break;
-    case NEU_REQ_INST_TEMPLATE:
-        data_size = sizeof(neu_req_inst_template_t);
-        break;
-    case NEU_REQ_INST_TEMPLATES:
-        data_size = sizeof(neu_req_inst_templates_t);
-        break;
-    case NEU_REQ_ADD_NODE:
-    case NEU_REQ_ADD_NODE_EVENT:
-        data_size = sizeof(neu_req_add_node_t);
-        break;
-    case NEU_REQ_UPDATE_NODE:
-        data_size = sizeof(neu_req_update_node_t);
-        break;
-    case NEU_REQ_DEL_NODE:
-    case NEU_REQ_DEL_NODE_EVENT:
-        data_size = sizeof(neu_req_del_node_t);
-        break;
-    case NEU_REQ_GET_NODE:
-        data_size = sizeof(neu_req_get_node_t);
-        break;
-    case NEU_RESP_GET_NODE:
-        data_size = sizeof(neu_resp_get_node_t);
-        break;
-    case NEU_REQ_ADD_GROUP:
-    case NEU_REQ_ADD_GROUP_EVENT:
-        data_size = sizeof(neu_req_add_group_t);
-        break;
-    case NEU_REQ_UPDATE_GROUP:
-    case NEU_REQ_UPDATE_DRIVER_GROUP:
-    case NEU_REQ_UPDATE_GROUP_EVENT:
-        data_size = sizeof(neu_req_update_group_t);
-        break;
-    case NEU_RESP_UPDATE_DRIVER_GROUP:
-        data_size = sizeof(neu_resp_update_group_t);
-        break;
-    case NEU_REQ_DEL_GROUP:
-    case NEU_REQ_DEL_GROUP_EVENT:
-        data_size = sizeof(neu_req_del_group_t);
-        break;
-    case NEU_REQ_GET_DRIVER_GROUP:
-    case NEU_REQ_GET_GROUP:
-        data_size = sizeof(neu_req_get_group_t);
-        break;
-    case NEU_RESP_GET_GROUP:
-        data_size = sizeof(neu_resp_get_group_t);
-        break;
-    case NEU_REQ_ADD_TAG:
-    case NEU_REQ_ADD_TAG_EVENT:
-        data_size = sizeof(neu_req_add_tag_t);
-        break;
-    case NEU_RESP_ADD_TAG:
-    case NEU_RESP_ADD_TEMPLATE_TAG:
-        data_size = sizeof(neu_resp_add_tag_t);
-        break;
-    case NEU_RESP_UPDATE_TAG:
-    case NEU_RESP_UPDATE_TEMPLATE_TAG:
-        data_size = sizeof(neu_resp_update_tag_t);
-        break;
-    case NEU_REQ_UPDATE_TAG:
-    case NEU_REQ_UPDATE_TAG_EVENT:
-        data_size = sizeof(neu_req_update_tag_t);
-        break;
-    case NEU_REQ_DEL_TAG:
-    case NEU_REQ_DEL_TAG_EVENT:
-        data_size = sizeof(neu_req_del_tag_t);
-        break;
-    case NEU_REQ_GET_TAG:
-        data_size = sizeof(neu_req_get_tag_t);
-        break;
-    case NEU_RESP_GET_TAG:
-    case NEU_RESP_GET_TEMPLATE_TAG:
-        data_size = sizeof(neu_resp_get_tag_t);
-        break;
-    case NEU_REQ_SUBSCRIBE_GROUP:
-    case NEU_REQ_UPDATE_SUBSCRIBE_GROUP:
-        data_size = sizeof(neu_req_subscribe_t);
-        break;
-    case NEU_REQ_UNSUBSCRIBE_GROUP:
-        data_size = sizeof(neu_req_unsubscribe_t);
-        break;
-    case NEU_REQ_SUBSCRIBE_GROUPS:
-        data_size = sizeof(neu_req_subscribe_groups_t);
-        break;
-    case NEU_REQ_GET_SUBSCRIBE_GROUP:
-    case NEU_REQ_GET_SUB_DRIVER_TAGS:
-        data_size = sizeof(neu_req_get_subscribe_group_t);
-        break;
-    case NEU_RESP_GET_SUB_DRIVER_TAGS:
-        data_size = sizeof(neu_resp_get_sub_driver_tags_t);
-        break;
-    case NEU_RESP_GET_SUBSCRIBE_GROUP:
-        data_size = sizeof(neu_resp_get_subscribe_group_t);
-        break;
-    case NEU_REQ_NODE_SETTING:
-    case NEU_REQ_NODE_SETTING_EVENT:
-        data_size = sizeof(neu_req_node_setting_t);
-        break;
-    case NEU_REQ_GET_NODE_SETTING:
-        data_size = sizeof(neu_req_get_node_setting_t);
-        break;
-    case NEU_RESP_GET_NODE_SETTING:
-        data_size = sizeof(neu_resp_get_node_setting_t);
-        break;
-    case NEU_REQ_NODE_CTL:
-    case NEU_REQ_NODE_CTL_EVENT:
-        data_size = sizeof(neu_req_node_ctl_t);
-        break;
-    case NEU_REQ_NODE_RENAME:
-        data_size = sizeof(neu_req_node_rename_t);
-        break;
-    case NEU_RESP_NODE_RENAME:
-        data_size = sizeof(neu_resp_node_rename_t);
-        break;
-    case NEU_REQ_GET_NODE_STATE:
-        data_size = sizeof(neu_req_get_node_state_t);
-        break;
-    case NEU_RESP_GET_NODE_STATE:
-        data_size = sizeof(neu_resp_get_node_state_t);
-        break;
-    case NEU_REQ_GET_NODES_STATE:
-        data_size = sizeof(neu_req_get_nodes_state_t);
-        break;
-    case NEU_REQRESP_NODES_STATE:
-    case NEU_RESP_GET_NODES_STATE:
-        data_size = sizeof(neu_resp_get_nodes_state_t);
-        break;
-    case NEU_REQ_READ_GROUP:
-        data_size = sizeof(neu_req_read_group_t);
-        break;
-    case NEU_REQ_WRITE_TAG:
-        data_size = sizeof(neu_req_write_tag_t);
-        break;
-    case NEU_REQ_WRITE_TAGS:
-        data_size = sizeof(neu_req_write_tags_t);
-        break;
-    case NEU_RESP_READ_GROUP:
-        data_size = sizeof(neu_resp_read_group_t);
-        break;
-    case NEU_REQRESP_NODE_DELETED:
-        data_size = sizeof(neu_reqresp_node_deleted_t);
-        break;
-    case NEU_RESP_GET_DRIVER_GROUP:
-        data_size = sizeof(neu_resp_get_driver_group_t);
-        break;
-    case NEU_REQ_ADD_NDRIVER_MAP:
-    case NEU_REQ_DEL_NDRIVER_MAP:
-        data_size = sizeof(neu_req_ndriver_map_t);
-        break;
-    case NEU_REQ_GET_NDRIVER_MAPS:
-        data_size = sizeof(neu_req_get_ndriver_maps_t);
-        break;
-    case NEU_RESP_GET_NDRIVER_MAPS:
-        data_size = sizeof(neu_resp_get_ndriver_maps_t);
-        break;
-    case NEU_REQ_UPDATE_NDRIVER_TAG_PARAM:
-        data_size = sizeof(neu_req_update_ndriver_tag_param_t);
-        break;
-    case NEU_REQ_UPDATE_NDRIVER_TAG_INFO:
-        data_size = sizeof(neu_req_update_ndriver_tag_info_t);
-        break;
-    case NEU_REQ_GET_NDRIVER_TAGS:
-        data_size = sizeof(neu_req_get_ndriver_tags_t);
-        break;
-    case NEU_RESP_GET_NDRIVER_TAGS:
-        data_size = sizeof(neu_resp_get_ndriver_tags_t);
-        break;
-    case NEU_REQ_UPDATE_LOG_LEVEL:
-        data_size = sizeof(neu_req_update_log_level_t);
-        break;
-    default:
-        assert(false);
-        break;
-    }
-
-    assert(NEU_MSG_MAX_SIZE >= sizeof(neu_reqresp_head_t) + data_size);
-    memcpy((uint8_t *) &header[1], data, data_size);
-    header->len = sizeof(neu_reqresp_head_t) + data_size;
-}

src/adapter/adapter_internal.h

@@ -26,6 +26,7 @@
 
 #include "adapter_info.h"
 #include "core/manager.h"
+#include "msg_q.h"
 
 struct neu_adapter {
     char *name;
@@ -33,23 +34,21 @@ struct neu_adapter {
 
     neu_node_running_state_e state;
 
-    char log_level[NEU_LOG_LEVEL_LEN];
-
     adapter_callbacks_t cb_funs;
 
     void *               handle;
     neu_plugin_module_t *module;
     neu_plugin_t *       plugin;
 
-    uint8_t buf[NEU_MSG_MAX_SIZE];
-    uint8_t recv_buf[NEU_MSG_MAX_SIZE];
-
     neu_event_io_t *control_io;
     neu_event_io_t *trans_data_io;
 
     int control_fd;
     int trans_data_fd;
 
+    adapter_msg_q_t *msg_q;
+    pthread_t        consumer_tid;
+
     uint16_t trans_data_port;
 
     neu_events_t *events;
@@ -59,6 +58,7 @@ struct neu_adapter {
 
     // metrics
     neu_node_metrics_t *metrics;
+    int                 log_level;
 };
 
 typedef void (*adapter_handler)(neu_adapter_t *     adapter,

src/adapter/driver/driver.c

@@ -81,6 +81,9 @@ struct neu_adapter_driver {
 };
 
 static int  report_callback(void *usr_data);
+static void report_to_app(neu_adapter_driver_t *driver, group_t *group,
+                          struct sockaddr_in dst);
+
 static int  read_callback(void *usr_data);
 static int  write_callback(void *usr_data);
 static void read_group(int64_t timestamp, int64_t timeout,
@@ -88,6 +91,7 @@ static void read_group(int64_t timestamp, int64_t timeout,
                        neu_driver_cache_t *cache, const char *group,
                        UT_array *tags, UT_array *tag_values);
 static void read_report_group(int64_t timestamp, int64_t timeout,
+                              neu_tag_cache_type_e cache_type,
                               neu_driver_cache_t *cache, const char *group,
                               UT_array *tags, UT_array *tag_values);
 static void update(neu_adapter_t *adapter, const char *group, const char *tag,
@@ -107,12 +111,19 @@ static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
     neu_reqresp_head_t *req    = (neu_reqresp_head_t *) r;
     neu_resp_error_t    nerror = { .error = error };
 
+    if (NEU_REQ_WRITE_TAG == req->type) {
+        neu_req_write_tag_fini((neu_req_write_tag_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_TAGS == req->type) {
+        neu_req_write_tags_fini((neu_req_write_tags_t *) &req[1]);
+    } else if (NEU_REQ_WRITE_GTAGS == req->type) {
+        neu_req_write_gtags_fini((neu_req_write_gtags_t *) &req[1]);
+    }
+
     req->type = NEU_RESP_ERROR;
 
     nlog_notice("write tag response <%p>", req->ctx);
 
     adapter->cb_funs.response(adapter, req, &nerror);
-    free(req);
 }
 
 static void update_with_meta(neu_adapter_t *adapter, const char *group,
@@ -169,9 +180,7 @@ static void update_im(neu_adapter_t *adapter, const char *group,
                       const char *tag, neu_dvalue_t value,
                       neu_tag_meta_t *metas, int n_meta)
 {
-    neu_adapter_driver_t *  driver    = (neu_adapter_driver_t *) adapter;
-    static __thread uint8_t buf[1024] = { 0 };
-    neu_reqresp_head_t *    header    = (neu_reqresp_head_t *) buf;
+    neu_adapter_driver_t *driver = (neu_adapter_driver_t *) adapter;
 
     if (tag == NULL || value.type == NEU_TYPE_ERROR) {
         nlog_warn("update_im tag is null or value is error %d",
@@ -207,17 +216,19 @@ static void update_im(neu_adapter_t *adapter, const char *group,
               driver->adapter.name, group, tag, neu_type_string(value.type),
               global_timestamp);
 
-    memset(buf, 0, sizeof(buf));
-    header->type = NEU_REQRESP_TRANS_DATA;
+    neu_reqresp_head_t header = {
+        .type = NEU_REQRESP_TRANS_DATA,
+    };
     neu_reqresp_trans_data_t *data =
         calloc(1, sizeof(neu_reqresp_trans_data_t));
 
-    strcpy(data->driver, driver->adapter.name);
-    strcpy(data->group, group);
+    data->driver = strdup(driver->adapter.name);
+    data->group  = strdup(group);
     utarray_new(data->tags, neu_resp_tag_value_meta_icd());
 
-    read_report_group(global_timestamp, 0, driver->cache, group, tags,
-                      data->tags);
+    read_report_group(global_timestamp, 0,
+                      neu_adapter_get_tag_cache_type(&driver->adapter),
+                      driver->cache, group, tags, data->tags);
 
     if (utarray_len(data->tags) > 0) {
         group_t *find = NULL;
@@ -225,29 +236,34 @@ static void update_im(neu_adapter_t *adapter, const char *group,
         if (find != NULL) {
             pthread_mutex_lock(&find->apps_mtx);
 
-            data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
-            data->ctx->index = utarray_len(find->apps);
-            if (data->ctx->index > 0) {
+            if (utarray_len(find->apps) > 0) {
+                data->ctx = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
+                data->ctx->index = utarray_len(find->apps);
                 pthread_mutex_init(&data->ctx->mtx, NULL);
 
                 utarray_foreach(find->apps, sub_app_t *, app)
                 {
                     if (driver->adapter.cb_funs.responseto(
-                            &driver->adapter, header, data, app->addr) <= 0) {
+                            &driver->adapter, &header, data, app->addr) != 0) {
                         neu_trans_data_free(data);
                     }
                 }
             } else {
                 utarray_free(data->tags);
-                free(data->ctx);
+                free(data->group);
+                free(data->driver);
             }
 
             pthread_mutex_unlock(&find->apps_mtx);
         } else {
             utarray_free(data->tags);
+            free(data->group);
+            free(data->driver);
         }
     } else {
         utarray_free(data->tags);
+        free(data->group);
+        free(data->driver);
     }
 
     utarray_free(tags);
@@ -385,6 +401,7 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
     if (g == NULL) {
         neu_resp_error_t error = { .error = NEU_ERR_GROUP_NOT_EXIST };
         req->type              = NEU_RESP_ERROR;
+        neu_req_read_group_fini(cmd);
         driver->adapter.cb_funs.response(&driver->adapter, req, &error);
         return;
     }
@@ -405,6 +422,30 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
 
             utarray_push_back(resp.tags, &tag_value);
         }
+    } else if (cmd->sync) {
+        if (NULL == driver->adapter.module->intf_funs->driver.group_sync) {
+            // plugin does not support sync read
+            utarray_foreach(tags, neu_datatag_t *, tag)
+            {
+                neu_resp_tag_value_meta_t tag_value = { 0 };
+                strcpy(tag_value.tag, tag->name);
+                tag_value.value.type = NEU_TYPE_ERROR;
+                tag_value.value.value.i32 =
+                    NEU_ERR_PLUGIN_NOT_SUPPORT_READ_SYNC;
+
+                utarray_push_back(resp.tags, &tag_value);
+            }
+        } else {
+            // sync read to update cache
+            driver->adapter.module->intf_funs->driver.group_sync(
+                driver->adapter.plugin, &g->grp);
+            // fetch updated data from cache
+            read_group(global_timestamp,
+                       neu_group_get_interval(group) *
+                           NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+                       neu_adapter_get_tag_cache_type(&driver->adapter),
+                       driver->cache, cmd->group, tags, resp.tags);
+        }
     } else {
         read_group(global_timestamp,
                    neu_group_get_interval(group) *
@@ -413,10 +454,13 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
                    driver->cache, cmd->group, tags, resp.tags);
     }
 
-    strcpy(resp.driver, cmd->driver);
-    strcpy(resp.group, cmd->group);
+    resp.driver = cmd->driver;
+    resp.group  = cmd->group;
+    cmd->driver = NULL; // ownership moved
+    cmd->group  = NULL; // ownership moved
 
     utarray_free(tags);
+    neu_req_read_group_fini(cmd);
 
     req->type = NEU_RESP_READ_GROUP;
     driver->adapter.cb_funs.response(&driver->adapter, req, &resp);
@@ -520,20 +564,62 @@ static void cal_decimal(neu_type_e tag_type, neu_type_e value_type,
 {
     switch (tag_type) {
     case NEU_TYPE_INT8:
-    case NEU_TYPE_UINT8:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->i8 = (int8_t) round(value->d64 / decimal);
+        } else {
+            value->i8 = (int8_t) round(value->i64 / decimal);
+        }
+        break;
     case NEU_TYPE_INT16:
-    case NEU_TYPE_UINT16:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->i16 = (int16_t) round(value->d64 / decimal);
+        } else {
+            value->i16 = (int16_t) round(value->i64 / decimal);
+        }
+        break;
     case NEU_TYPE_INT32:
-    case NEU_TYPE_UINT32:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->i32 = (int32_t) round(value->d64 / decimal);
+        } else {
+            value->i32 = (int32_t) round(value->i64 / decimal);
+        }
+        break;
     case NEU_TYPE_INT64:
-    case NEU_TYPE_UINT64:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->i64 = (int64_t) round(value->d64 / decimal);
+        } else {
+            value->i64 = (int64_t) round(value->i64 / decimal);
+        }
+        break;
+    case NEU_TYPE_UINT8:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->u8 = (uint8_t) round(value->d64 / decimal);
+        } else {
+            value->u8 = (uint8_t) round(value->u64 / decimal);
+        }
+        break;
+    case NEU_TYPE_UINT16:
     case NEU_TYPE_WORD:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->u16 = (uint16_t) round(value->d64 / decimal);
+        } else {
+            value->u16 = (uint16_t) round(value->u64 / decimal);
+        }
+        break;
+    case NEU_TYPE_UINT32:
     case NEU_TYPE_LWORD:
+        if (value_type == NEU_TYPE_DOUBLE) {
+            value->u32 = (uint32_t) round(value->d64 / decimal);
+        } else {
+            value->u32 = (uint32_t) round(value->u64 / decimal);
+        }
+        break;
+    case NEU_TYPE_UINT64:
     case NEU_TYPE_DWORD:
-        if (value_type == NEU_TYPE_INT64 || value_type == NEU_TYPE_LWORD) {
-            value->u64 = value->u64 / decimal;
-        } else if (value_type == NEU_TYPE_DOUBLE) {
+        if (value_type == NEU_TYPE_DOUBLE) {
             value->u64 = (uint64_t) round(value->d64 / decimal);
+        } else {
+            value->u64 = (uint64_t) round(value->u64 / decimal);
         }
         break;
     case NEU_TYPE_FLOAT:
@@ -551,25 +637,18 @@ static void cal_decimal(neu_type_e tag_type, neu_type_e value_type,
     }
 }
 
-static void free_tags(neu_req_write_tags_t *cmd)
-{
-    free(cmd->tags);
-}
-
 void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
                                    neu_reqresp_head_t *  req)
 {
     neu_req_write_tags_t *cmd = (neu_req_write_tags_t *) &req[1];
 
     if (driver->adapter.state != NEU_NODE_RUNNING_STATE_RUNNING) {
-        free_tags(cmd);
         driver->adapter.cb_funs.driver.write_response(
             &driver->adapter, req, NEU_ERR_PLUGIN_NOT_RUNNING);
         return;
     }
 
     if (driver->adapter.module->intf_funs->driver.write_tags == NULL) {
-        free_tags(cmd);
         driver->adapter.cb_funs.driver.write_response(
             &driver->adapter, req, NEU_ERR_PLUGIN_NOT_SUPPORT_WRITE_TAGS);
         return;
@@ -578,11 +657,8 @@ void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
     group_t *g = find_group(driver, cmd->group);
 
     if (g == NULL) {
-        neu_resp_error_t error = { .error = NEU_ERR_GROUP_NOT_EXIST };
-        req->type              = NEU_RESP_ERROR;
-        free_tags(cmd);
-        driver->adapter.cb_funs.response(&driver->adapter, req, &error);
-        free(req);
+        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                      NEU_ERR_GROUP_NOT_EXIST);
         return;
     }
 
@@ -590,16 +666,13 @@ void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
     UT_icd    icd  = { sizeof(neu_plugin_tag_value_t), NULL, NULL, NULL };
     utarray_new(tags, &icd);
     for (int i = 0; i < cmd->n_tag; i++) {
-        neu_plugin_tag_value_t tv = { 0 };
-
         neu_datatag_t *tag = neu_group_find_tag(g->group, cmd->tags[i].tag);
         if (tag != NULL && neu_tag_attribute_test(tag, NEU_ATTRIBUTE_WRITE) &&
             neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) == false) {
-            tv.tag = neu_tag_dup(tag);
-
             if (tag->type == NEU_TYPE_FLOAT || tag->type == NEU_TYPE_DOUBLE) {
                 if (cmd->tags[i].value.type == NEU_TYPE_INT64) {
-                    tv.value.d64 = (double) tv.value.u64;
+                    cmd->tags[i].value.value.d64 =
+                        (double) cmd->tags[i].value.value.i64;
                 }
             }
             if (tag->decimal != 0) {
@@ -608,7 +681,10 @@ void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
             }
             fix_value(tag, cmd->tags[i].value.type, &cmd->tags[i].value);
 
-            tv.value = cmd->tags[i].value.value;
+            neu_plugin_tag_value_t tv = {
+                .tag   = neu_tag_dup(tag),
+                .value = cmd->tags[i].value.value,
+            };
             utarray_push_back(tags, &tv);
         }
         if (tag != NULL) {
@@ -617,11 +693,8 @@ void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
     }
 
     if (utarray_len(tags) != (unsigned int) cmd->n_tag) {
-        neu_resp_error_t error = { .error = NEU_ERR_TAG_NOT_EXIST };
-        req->type              = NEU_RESP_ERROR;
-        free_tags(cmd);
-        driver->adapter.cb_funs.response(&driver->adapter, req, &error);
-        free(req);
+        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                      NEU_ERR_TAG_NOT_EXIST);
         utarray_foreach(tags, neu_plugin_tag_value_t *, tv)
         {
             neu_tag_free(tv->tag);
@@ -636,7 +709,102 @@ void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
     wtag.tvs               = tags;
 
     store_write_tag(g, &wtag);
-    free_tags(cmd);
+}
+
+void neu_adapter_driver_write_gtags(neu_adapter_driver_t *driver,
+                                    neu_reqresp_head_t *  req)
+{
+    neu_req_write_gtags_t *cmd     = (neu_req_write_gtags_t *) &req[1];
+    group_t *              first_g = NULL;
+
+    if (driver->adapter.state != NEU_NODE_RUNNING_STATE_RUNNING) {
+        driver->adapter.cb_funs.driver.write_response(
+            &driver->adapter, req, NEU_ERR_PLUGIN_NOT_RUNNING);
+        return;
+    }
+
+    if (driver->adapter.module->intf_funs->driver.write_tags == NULL) {
+        driver->adapter.cb_funs.driver.write_response(
+            &driver->adapter, req, NEU_ERR_PLUGIN_NOT_SUPPORT_WRITE_TAGS);
+        return;
+    }
+
+    for (int i = 0; i < cmd->n_group; i++) {
+        group_t *g = find_group(driver, cmd->groups[i].group);
+
+        if (g == NULL) {
+            driver->adapter.cb_funs.driver.write_response(
+                &driver->adapter, req, NEU_ERR_GROUP_NOT_EXIST);
+            return;
+        }
+
+        if (first_g == NULL) {
+            first_g = g;
+        }
+    }
+
+    UT_array *tags = NULL;
+    UT_icd    icd  = { sizeof(neu_plugin_tag_value_t), NULL, NULL, NULL };
+    utarray_new(tags, &icd);
+
+    for (int i = 0; i < cmd->n_group; i++) {
+        group_t *g = find_group(driver, cmd->groups[i].group);
+
+        for (int k = 0; k < cmd->groups[i].n_tag; k++) {
+            neu_datatag_t *tag =
+                neu_group_find_tag(g->group, cmd->groups[i].tags[k].tag);
+            if (tag != NULL &&
+                neu_tag_attribute_test(tag, NEU_ATTRIBUTE_WRITE) &&
+                neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) == false) {
+                if (tag->type == NEU_TYPE_FLOAT ||
+                    tag->type == NEU_TYPE_DOUBLE) {
+                    if (cmd->groups[i].tags[k].value.type == NEU_TYPE_INT64) {
+                        cmd->groups[i].tags[k].value.value.d64 =
+                            (double) cmd->groups[i].tags[k].value.value.i64;
+                    }
+                }
+                if (tag->decimal != 0) {
+                    cal_decimal(tag->type, cmd->groups[i].tags[k].value.type,
+                                &cmd->groups[i].tags[k].value.value,
+                                tag->decimal);
+                }
+                fix_value(tag, cmd->groups[i].tags[k].value.type,
+                          &cmd->groups[i].tags[k].value);
+
+                neu_plugin_tag_value_t tv = {
+                    tv.tag   = neu_tag_dup(tag),
+                    tv.value = cmd->groups[i].tags[k].value.value,
+                };
+                utarray_push_back(tags, &tv);
+            }
+            if (tag != NULL) {
+                neu_tag_free(tag);
+            }
+        }
+    }
+
+    uint32_t n_tag = 0;
+    for (int i = 0; i < cmd->n_group; i++) {
+        n_tag += cmd->groups[i].n_tag;
+    }
+
+    if (utarray_len(tags) != (unsigned int) n_tag) {
+        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                      NEU_ERR_TAG_NOT_EXIST);
+        utarray_foreach(tags, neu_plugin_tag_value_t *, tv)
+        {
+            neu_tag_free(tv->tag);
+        }
+        utarray_free(tags);
+        return;
+    }
+
+    to_be_write_tag_t wtag = { 0 };
+    wtag.single            = false;
+    wtag.req               = (void *) req;
+    wtag.tvs               = tags;
+
+    store_write_tag(first_g, &wtag);
 }
 
 void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
@@ -652,20 +820,15 @@ void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
     group_t *            g   = find_group(driver, cmd->group);
 
     if (g == NULL) {
-        neu_resp_error_t error = { .error = NEU_ERR_GROUP_NOT_EXIST };
-        req->type              = NEU_RESP_ERROR;
-        driver->adapter.cb_funs.response(&driver->adapter, req, &error);
-        free(req);
+        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                      NEU_ERR_GROUP_NOT_EXIST);
         return;
     }
     neu_datatag_t *tag = neu_group_find_tag(g->group, cmd->tag);
 
     if (tag == NULL) {
-        neu_resp_error_t error = { .error = NEU_ERR_TAG_NOT_EXIST };
-
-        req->type = NEU_RESP_ERROR;
-        driver->adapter.cb_funs.response(&driver->adapter, req, &error);
-        free(req);
+        driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                      NEU_ERR_TAG_NOT_EXIST);
     } else {
         if ((tag->attribute & NEU_ATTRIBUTE_WRITE) != NEU_ATTRIBUTE_WRITE) {
             driver->adapter.cb_funs.driver.write_response(
@@ -675,7 +838,7 @@ void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
         }
         if (tag->type == NEU_TYPE_FLOAT || tag->type == NEU_TYPE_DOUBLE) {
             if (cmd->value.type == NEU_TYPE_INT64) {
-                cmd->value.value.d64 = (double) cmd->value.value.u64;
+                cmd->value.value.d64 = (double) cmd->value.value.i64;
             }
         }
 
@@ -692,10 +855,8 @@ void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
             neu_tag_set_static_value(tag, &cmd->value.value);
             neu_group_update_tag(g->group, tag);
             adapter_storage_update_tag_value(cmd->driver, cmd->group, tag);
-            neu_resp_error_t error = { .error = NEU_ERR_SUCCESS };
-            req->type              = NEU_RESP_ERROR;
-            driver->adapter.cb_funs.response(&driver->adapter, req, &error);
-            free(req);
+            driver->adapter.cb_funs.driver.write_response(&driver->adapter, req,
+                                                          NEU_ERR_SUCCESS);
         } else {
             to_be_write_tag_t wtag = { 0 };
             wtag.single            = true;
@@ -1061,8 +1222,8 @@ int neu_adapter_driver_add_tag(neu_adapter_driver_t *driver, const char *group,
 
     HASH_FIND_STR(driver->groups, group, find);
     if (find == NULL) {
-        neu_adapter_driver_add_group(driver, group, 3000);
-        adapter_storage_add_group(driver->adapter.name, group, 3000);
+        neu_adapter_driver_add_group(driver, group, 1000);
+        adapter_storage_add_group(driver->adapter.name, group, 1000);
     }
     HASH_FIND_STR(driver->groups, group, find);
     assert(find != NULL);
@@ -1242,18 +1403,12 @@ UT_array *neu_adapter_driver_get_ptag(neu_adapter_driver_t *driver,
     return tags;
 }
 
-static int report_callback(void *usr_data)
+static void report_to_app(neu_adapter_driver_t *driver, group_t *group,
+                          struct sockaddr_in dst)
 {
-    group_t *                group     = (group_t *) usr_data;
-    static __thread uint8_t  buf[1024] = { 0 };
-    neu_reqresp_head_t *     header    = (neu_reqresp_head_t *) buf;
-    neu_node_running_state_e state     = group->driver->adapter.state;
-    if (state != NEU_NODE_RUNNING_STATE_RUNNING) {
-        return 0;
-    }
-
-    memset(buf, 0, sizeof(buf));
-    header->type = NEU_REQRESP_TRANS_DATA;
+    neu_reqresp_head_t header = {
+        .type = NEU_REQRESP_TRANS_DATA,
+    };
 
     UT_array *tags =
         neu_adapter_driver_get_read_tag(group->driver, group->name);
@@ -1261,14 +1416,15 @@ static int report_callback(void *usr_data)
     neu_reqresp_trans_data_t *data =
         calloc(1, sizeof(neu_reqresp_trans_data_t));
 
-    strcpy(data->driver, group->driver->adapter.name);
-    strcpy(data->group, group->name);
+    data->driver = strdup(group->driver->adapter.name);
+    data->group  = strdup(group->name);
     utarray_new(data->tags, neu_resp_tag_value_meta_icd());
 
-    read_report_group(global_timestamp,
-                      neu_group_get_interval(group->group) *
-                          NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
-                      group->driver->cache, group->name, tags, data->tags);
+    read_group(global_timestamp,
+               neu_group_get_interval(group->group) *
+                   NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+               neu_adapter_get_tag_cache_type(&driver->adapter), driver->cache,
+               group->name, tags, data->tags);
 
     nlog_info("report group: %s, all tags: %d, report tags: %d", group->name,
               utarray_len(tags), utarray_len(data->tags));
@@ -1276,27 +1432,88 @@ static int report_callback(void *usr_data)
         pthread_mutex_lock(&group->apps_mtx);
 
         data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
-        data->ctx->index = utarray_len(group->apps);
+        data->ctx->index = 1;
 
-        if (data->ctx->index > 0) {
-            pthread_mutex_init(&data->ctx->mtx, NULL);
+        pthread_mutex_init(&data->ctx->mtx, NULL);
 
-            utarray_foreach(group->apps, sub_app_t *, app)
-            {
-                if (group->driver->adapter.cb_funs.responseto(
-                        &group->driver->adapter, header, data, app->addr) <=
-                    0) {
-                    neu_trans_data_free(data);
-                }
-            }
-        } else {
-            utarray_free(data->tags);
-            free(data->ctx);
+        if (driver->adapter.cb_funs.responseto(&driver->adapter, &header, data,
+                                               dst) != 0) {
+            neu_trans_data_free(data);
         }
 
         pthread_mutex_unlock(&group->apps_mtx);
     } else {
         utarray_free(data->tags);
+        free(data->group);
+        free(data->driver);
+    }
+    utarray_free(tags);
+    free(data);
+}
+
+static int report_callback(void *usr_data)
+{
+    group_t *                group = (group_t *) usr_data;
+    neu_node_running_state_e state = group->driver->adapter.state;
+    if (state != NEU_NODE_RUNNING_STATE_RUNNING) {
+        return 0;
+    }
+
+    neu_reqresp_head_t header = {
+        .type = NEU_REQRESP_TRANS_DATA,
+    };
+
+    UT_array *tags =
+        neu_adapter_driver_get_read_tag(group->driver, group->name);
+
+    neu_reqresp_trans_data_t *data =
+        calloc(1, sizeof(neu_reqresp_trans_data_t));
+
+    data->driver = strdup(group->driver->adapter.name);
+    data->group  = strdup(group->name);
+    utarray_new(data->tags, neu_resp_tag_value_meta_icd());
+
+    read_report_group(global_timestamp,
+                      neu_group_get_interval(group->group) *
+                          NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+                      neu_adapter_get_tag_cache_type(&group->driver->adapter),
+                      group->driver->cache, group->name, tags, data->tags);
+
+    nlog_info("report group: %s, all tags: %d, report tags: %d", group->name,
+              utarray_len(tags), utarray_len(data->tags));
+    if (utarray_len(data->tags) > 0) {
+        pthread_mutex_lock(&group->apps_mtx);
+
+        if (utarray_len(group->apps) > 0) {
+            data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
+            data->ctx->index = utarray_len(group->apps);
+            pthread_mutex_init(&data->ctx->mtx, NULL);
+
+            utarray_foreach(group->apps, sub_app_t *, app)
+            {
+                if (group->driver->adapter.cb_funs.responseto(
+                        &group->driver->adapter, &header, data, app->addr) !=
+                    0) {
+                    neu_trans_data_free(data);
+                }
+            }
+        } else {
+            utarray_foreach(data->tags, neu_resp_tag_value_meta_t *, tag_value)
+            {
+                if (tag_value->value.type == NEU_TYPE_PTR) {
+                    free(tag_value->value.value.ptr.ptr);
+                }
+            }
+            utarray_free(data->tags);
+            free(data->group);
+            free(data->driver);
+        }
+
+        pthread_mutex_unlock(&group->apps_mtx);
+    } else {
+        utarray_free(data->tags);
+        free(data->group);
+        free(data->driver);
     }
     utarray_free(tags);
     free(data);
@@ -1435,6 +1652,7 @@ static int read_callback(void *usr_data)
 }
 
 static void read_report_group(int64_t timestamp, int64_t timeout,
+                              neu_tag_cache_type_e cache_type,
                               neu_driver_cache_t *cache, const char *group,
                               UT_array *tags, UT_array *tag_values)
 {
@@ -1527,7 +1745,8 @@ static void read_report_group(int64_t timestamp, int64_t timeout,
             break;
         }
 
-        if (!neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
+        if (cache_type != NEU_TAG_CACHE_TYPE_NEVER &&
+            !neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
             (timestamp - value.timestamp) > timeout && timeout > 0) {
             tag_value.value.type      = NEU_TYPE_ERROR;
             tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
@@ -1783,6 +2002,8 @@ void neu_adapter_driver_subscribe(neu_adapter_driver_t *driver,
 
     utarray_push_back(find->apps, &sub_app);
     pthread_mutex_unlock(&find->apps_mtx);
+
+    report_to_app(driver, find, sub_app.addr);
 }
 
 void neu_adapter_driver_unsubscribe(neu_adapter_driver_t * driver,

src/adapter/driver/driver_internal.h

@@ -40,6 +40,8 @@ void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
                                   neu_reqresp_head_t *  req);
 void neu_adapter_driver_write_tags(neu_adapter_driver_t *driver,
                                    neu_reqresp_head_t *  req);
+void neu_adapter_driver_write_gtags(neu_adapter_driver_t *driver,
+                                    neu_reqresp_head_t *  req);
 
 int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
                                  uint32_t interval);

src/adapter/msg_q.c

@@ -0,0 +1,116 @@
+/**
+ * NEURON IIoT System for Industry 4.0
+ * Copyright (C) 2020-2024 EMQ Technologies Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+#include <pthread.h>
+
+#include "utils/log.h"
+#include "utils/utextend.h"
+
+#include "msg_q.h"
+
+struct item {
+    neu_msg_t *  msg;
+    struct item *prev, *next;
+};
+
+struct adapter_msg_q {
+    struct item *list;
+    uint32_t     max;
+    uint32_t     current;
+    char *       name;
+
+    pthread_mutex_t mtx;
+    pthread_cond_t  cond;
+};
+
+adapter_msg_q_t *adapter_msg_q_new(const char *name, uint32_t size)
+{
+    struct adapter_msg_q *q = calloc(1, sizeof(struct adapter_msg_q));
+
+    pthread_mutex_init(&q->mtx, NULL);
+    pthread_cond_init(&q->cond, NULL);
+    q->max     = size;
+    q->name    = strdup(name);
+    q->current = 0;
+
+    return q;
+}
+
+void adapter_msg_q_free(adapter_msg_q_t *q)
+{
+    struct item *tmp = NULL, *elt = NULL;
+    nlog_warn("app: %s, drop %u msg", q->name, q->current);
+    pthread_mutex_destroy(&q->mtx);
+    pthread_cond_destroy(&q->cond);
+
+    DL_FOREACH_SAFE(q->list, elt, tmp)
+    {
+        DL_DELETE(q->list, elt);
+        neu_reqresp_head_t *header = neu_msg_get_header(elt->msg);
+        neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
+        neu_msg_free(elt->msg);
+        free(elt);
+    }
+    free(q->name);
+    free(q);
+}
+
+int adapter_msg_q_push(adapter_msg_q_t *q, neu_msg_t *msg)
+{
+    int ret = -1;
+    pthread_mutex_lock(&q->mtx);
+    if (q->current < q->max) {
+        q->current += 1;
+        struct item *elt = calloc(1, sizeof(struct item));
+        elt->msg         = msg;
+        DL_APPEND(q->list, elt);
+        ret = 0;
+    }
+    pthread_mutex_unlock(&q->mtx);
+
+    if (ret == -1) {
+        nlog_warn("app: %s, msg q is full, %u(%u)", q->name, q->current,
+                  q->max);
+    } else {
+        pthread_cond_signal(&q->cond);
+    }
+
+    return ret;
+}
+
+uint32_t adapter_msg_q_pop(adapter_msg_q_t *q, neu_msg_t **p_data)
+{
+    uint32_t ret = 0;
+
+    pthread_mutex_lock(&q->mtx);
+    while (q->current == 0) {
+        pthread_cond_wait(&q->cond, &q->mtx);
+    }
+    struct item *elt = DL_LAST(q->list);
+
+    if (elt != NULL) {
+        DL_DELETE(q->list, elt);
+        *p_data = elt->msg;
+        free(elt);
+        q->current -= 1;
+        ret = q->current;
+    }
+
+    pthread_mutex_unlock(&q->mtx);
+    return ret;
+}

src/adapter/msg_q.h

@@ -1,6 +1,6 @@
 /**
  * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
+ * Copyright (C) 2020-2024 EMQ Technologies Co., Ltd All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,12 +17,20 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
 
-#ifndef _NEU_FILE_HANDLE_H_
-#define _NEU_FILE_HANDLE_H_
+#ifndef ADAPTER_MSG_Q_H
+#define ADAPTER_MSG_Q_H
 
-#include <nng/nng.h>
+#include <stdint.h>
 
-void handle_download_file(nng_aio *aio);
-void handle_file_info(nng_aio *aio);
+#include "base/msg_internal.h"
+#include "msg.h"
+
+typedef struct adapter_msg_q adapter_msg_q_t;
+
+adapter_msg_q_t *adapter_msg_q_new(const char *name, uint32_t size);
+void             adapter_msg_q_free(adapter_msg_q_t *q);
+
+int      adapter_msg_q_push(adapter_msg_q_t *q, neu_msg_t *msg);
+uint32_t adapter_msg_q_pop(adapter_msg_q_t *q, neu_msg_t **p_data);
 
 #endif

src/base/group.c

@@ -16,6 +16,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
+#include <pthread.h>
 #include <string.h>
 #include <sys/time.h>
 
@@ -38,7 +39,8 @@ struct neu_group {
     tag_elem_t *tags;
     uint32_t    interval;
 
-    int64_t timestamp;
+    int64_t         timestamp;
+    pthread_mutex_t mtx;
 };
 
 static UT_array *to_array(tag_elem_t *tags);
@@ -53,6 +55,7 @@ neu_group_t *neu_group_new(const char *name, uint32_t interval)
 
     group->name     = strdup(name);
     group->interval = interval;
+    pthread_mutex_init(&group->mtx, NULL);
 
     return group;
 }
@@ -61,6 +64,7 @@ void neu_group_destroy(neu_group_t *group)
 {
     tag_elem_t *el = NULL, *tmp = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     HASH_ITER(hh, group->tags, el, tmp)
     {
         HASH_DEL(group->tags, el);
@@ -68,7 +72,9 @@ void neu_group_destroy(neu_group_t *group)
         neu_tag_free(el->tag);
         free(el);
     }
+    pthread_mutex_unlock(&group->mtx);
 
+    pthread_mutex_destroy(&group->mtx);
     free(group->name);
     free(group);
 }
@@ -118,8 +124,10 @@ int neu_group_add_tag(neu_group_t *group, const neu_datatag_t *tag)
 {
     tag_elem_t *el = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     HASH_FIND_STR(group->tags, tag->name, el);
     if (el != NULL) {
+        pthread_mutex_unlock(&group->mtx);
         return NEU_ERR_TAG_NAME_CONFLICT;
     }
 
@@ -129,6 +137,7 @@ int neu_group_add_tag(neu_group_t *group, const neu_datatag_t *tag)
 
     HASH_ADD_STR(group->tags, name, el);
     update_timestamp(group);
+    pthread_mutex_unlock(&group->mtx);
 
     return 0;
 }
@@ -138,6 +147,7 @@ int neu_group_update_tag(neu_group_t *group, const neu_datatag_t *tag)
     tag_elem_t *el  = NULL;
     int         ret = NEU_ERR_TAG_NOT_EXIST;
 
+    pthread_mutex_lock(&group->mtx);
     HASH_FIND_STR(group->tags, tag->name, el);
     if (el != NULL) {
         neu_tag_copy(el->tag, tag);
@@ -145,6 +155,7 @@ int neu_group_update_tag(neu_group_t *group, const neu_datatag_t *tag)
         update_timestamp(group);
         ret = NEU_ERR_SUCCESS;
     }
+    pthread_mutex_unlock(&group->mtx);
 
     return ret;
 }
@@ -154,6 +165,7 @@ int neu_group_del_tag(neu_group_t *group, const char *tag_name)
     tag_elem_t *el  = NULL;
     int         ret = NEU_ERR_TAG_NOT_EXIST;
 
+    pthread_mutex_lock(&group->mtx);
     HASH_FIND_STR(group->tags, tag_name, el);
     if (el != NULL) {
         HASH_DEL(group->tags, el);
@@ -164,15 +176,18 @@ int neu_group_del_tag(neu_group_t *group, const char *tag_name)
         update_timestamp(group);
         ret = NEU_ERR_SUCCESS;
     }
+    pthread_mutex_unlock(&group->mtx);
 
     return ret;
 }
 
-UT_array *neu_group_get_tag(const neu_group_t *group)
+UT_array *neu_group_get_tag(neu_group_t *group)
 {
     UT_array *array = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     array = to_array(group->tags);
+    pthread_mutex_unlock(&group->mtx);
 
     return array;
 }
@@ -182,6 +197,7 @@ UT_array *neu_group_query_tag(neu_group_t *group, const char *name)
     tag_elem_t *el = NULL, *tmp = NULL;
     UT_array *  array = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     utarray_new(array, neu_tag_get_icd());
     HASH_ITER(hh, group->tags, el, tmp)
     {
@@ -189,6 +205,7 @@ UT_array *neu_group_query_tag(neu_group_t *group, const char *name)
             utarray_push_back(array, el->tag);
         }
     }
+    pthread_mutex_unlock(&group->mtx);
 
     return array;
 }
@@ -197,7 +214,9 @@ UT_array *neu_group_get_read_tag(neu_group_t *group)
 {
     UT_array *array = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     array = to_read_array(group->tags);
+    pthread_mutex_unlock(&group->mtx);
 
     return array;
 }
@@ -216,10 +235,12 @@ neu_datatag_t *neu_group_find_tag(neu_group_t *group, const char *tag)
     tag_elem_t *   find   = NULL;
     neu_datatag_t *result = NULL;
 
+    pthread_mutex_lock(&group->mtx);
     HASH_FIND_STR(group->tags, tag, find);
     if (find != NULL) {
         result = neu_tag_dup(find->tag);
     }
+    pthread_mutex_unlock(&group->mtx);
 
     return result;
 }

src/base/group.h

@@ -38,7 +38,7 @@ int          neu_group_update(neu_group_t *group, uint32_t interval);
 int          neu_group_add_tag(neu_group_t *group, const neu_datatag_t *tag);
 int          neu_group_update_tag(neu_group_t *group, const neu_datatag_t *tag);
 int          neu_group_del_tag(neu_group_t *group, const char *tag_name);
-UT_array *   neu_group_get_tag(const neu_group_t *group);
+UT_array *   neu_group_get_tag(neu_group_t *group);
 UT_array *   neu_group_query_tag(neu_group_t *group, const char *name);
 UT_array *   neu_group_get_read_tag(neu_group_t *group);
 uint16_t     neu_group_tag_size(const neu_group_t *group);

src/base/msg.c

@@ -0,0 +1,68 @@
+/**
+ * NEURON IIoT System for Industry 4.0
+ * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+
+#include "msg.h"
+#include "utils/log.h"
+
+#include "msg_internal.h"
+
+void neu_msg_gen(neu_reqresp_head_t *header, void *data)
+{
+    size_t data_size = neu_reqresp_size(header->type);
+    assert(header->len >= sizeof(neu_reqresp_head_t) + data_size);
+    memcpy((uint8_t *) &header[1], data, data_size);
+}
+
+neu_reqresp_head_t *neu_msg_dup(neu_reqresp_head_t *header)
+{
+    neu_reqresp_head_t *new_header = calloc(1, header->len);
+
+    *new_header = *header;
+    switch (new_header->type) {
+    case NEU_REQ_WRITE_TAG: {
+        neu_req_write_tag_t *wt     = (neu_req_write_tag_t *) &header[1];
+        neu_req_write_tag_t *new_wt = (neu_req_write_tag_t *) &new_header[1];
+
+        *new_wt = *wt;
+        break;
+    }
+    case NEU_REQ_WRITE_TAGS: {
+        neu_req_write_tags_t *wts     = (neu_req_write_tags_t *) &header[1];
+        neu_req_write_tags_t *new_wts = (neu_req_write_tags_t *) &new_header[1];
+
+        *new_wts = *wts;
+        break;
+    }
+    case NEU_REQ_WRITE_GTAGS: {
+        neu_req_write_gtags_t *wgts = (neu_req_write_gtags_t *) &header[1];
+        neu_req_write_gtags_t *new_wgts =
+            (neu_req_write_gtags_t *) &new_header[1];
+
+        *new_wgts = *wgts;
+        break;
+    }
+    default:
+        nlog_warn("unsupport msg type %d", new_header->type);
+        assert(false);
+    }
+
+    memcpy(&new_header[1], &header[1], header->len - sizeof(*header));
+
+    return new_header;
+}

src/base/msg_internal.h

@@ -0,0 +1,293 @@
+/**
+ * NEURON IIoT System for Industry 4.0
+ * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+
+#ifndef NEURON_MSG_INTERNAL_H
+#define NEURON_MSG_INTERNAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include "msg.h"
+
+#define NEU_REQRESP_TYPE_MAP(XX)                                             \
+    XX(NEU_RESP_ERROR, neu_resp_error_t)                                     \
+    XX(NEU_REQ_READ_GROUP, neu_req_read_group_t)                             \
+    XX(NEU_RESP_READ_GROUP, neu_resp_read_group_t)                           \
+    XX(NEU_REQ_WRITE_TAG, neu_req_write_tag_t)                               \
+    XX(NEU_REQ_WRITE_TAGS, neu_req_write_tags_t)                             \
+    XX(NEU_REQ_WRITE_GTAGS, neu_req_write_gtags_t)                           \
+    XX(NEU_REQ_SUBSCRIBE_GROUP, neu_req_subscribe_t)                         \
+    XX(NEU_REQ_UNSUBSCRIBE_GROUP, neu_req_unsubscribe_t)                     \
+    XX(NEU_REQ_UPDATE_SUBSCRIBE_GROUP, neu_req_subscribe_t)                  \
+    XX(NEU_REQ_SUBSCRIBE_GROUPS, neu_req_subscribe_groups_t)                 \
+    XX(NEU_REQ_GET_SUBSCRIBE_GROUP, neu_req_get_subscribe_group_t)           \
+    XX(NEU_RESP_GET_SUBSCRIBE_GROUP, neu_resp_get_subscribe_group_t)         \
+    XX(NEU_REQ_GET_SUB_DRIVER_TAGS, neu_req_get_sub_driver_tags_t)           \
+    XX(NEU_RESP_GET_SUB_DRIVER_TAGS, neu_resp_get_sub_driver_tags_t)         \
+    XX(NEU_REQ_NODE_INIT, neu_req_node_init_t)                               \
+    XX(NEU_REQ_NODE_UNINIT, neu_req_node_uninit_t)                           \
+    XX(NEU_RESP_NODE_UNINIT, neu_resp_node_uninit_t)                         \
+    XX(NEU_REQ_ADD_NODE, neu_req_add_node_t)                                 \
+    XX(NEU_REQ_UPDATE_NODE, neu_req_update_node_t)                           \
+    XX(NEU_REQ_DEL_NODE, neu_req_del_node_t)                                 \
+    XX(NEU_REQ_GET_NODE, neu_req_get_node_t)                                 \
+    XX(NEU_RESP_GET_NODE, neu_resp_get_node_t)                               \
+    XX(NEU_REQ_NODE_SETTING, neu_req_node_setting_t)                         \
+    XX(NEU_REQ_GET_NODE_SETTING, neu_req_get_node_setting_t)                 \
+    XX(NEU_RESP_GET_NODE_SETTING, neu_resp_get_node_setting_t)               \
+    XX(NEU_REQ_GET_NODE_STATE, neu_req_get_node_state_t)                     \
+    XX(NEU_RESP_GET_NODE_STATE, neu_resp_get_node_state_t)                   \
+    XX(NEU_REQ_GET_NODES_STATE, neu_req_get_nodes_state_t)                   \
+    XX(NEU_RESP_GET_NODES_STATE, neu_resp_get_nodes_state_t)                 \
+    XX(NEU_REQ_NODE_CTL, neu_req_node_ctl_t)                                 \
+    XX(NEU_REQ_NODE_RENAME, neu_req_node_rename_t)                           \
+    XX(NEU_RESP_NODE_RENAME, neu_resp_node_rename_t)                         \
+    XX(NEU_REQ_ADD_GROUP, neu_req_add_group_t)                               \
+    XX(NEU_REQ_DEL_GROUP, neu_req_del_group_t)                               \
+    XX(NEU_REQ_UPDATE_GROUP, neu_req_update_group_t)                         \
+    XX(NEU_REQ_UPDATE_DRIVER_GROUP, neu_req_update_group_t)                  \
+    XX(NEU_RESP_UPDATE_DRIVER_GROUP, neu_resp_update_group_t)                \
+    XX(NEU_REQ_GET_GROUP, neu_req_get_group_t)                               \
+    XX(NEU_RESP_GET_GROUP, neu_resp_get_group_t)                             \
+    XX(NEU_REQ_GET_DRIVER_GROUP, neu_req_get_group_t)                        \
+    XX(NEU_RESP_GET_DRIVER_GROUP, neu_resp_get_driver_group_t)               \
+    XX(NEU_REQ_ADD_TAG, neu_req_add_tag_t)                                   \
+    XX(NEU_RESP_ADD_TAG, neu_resp_add_tag_t)                                 \
+    XX(NEU_REQ_DEL_TAG, neu_req_del_tag_t)                                   \
+    XX(NEU_REQ_UPDATE_TAG, neu_req_update_tag_t)                             \
+    XX(NEU_RESP_UPDATE_TAG, neu_resp_update_tag_t)                           \
+    XX(NEU_REQ_GET_TAG, neu_req_get_tag_t)                                   \
+    XX(NEU_RESP_GET_TAG, neu_resp_get_tag_t)                                 \
+    XX(NEU_REQ_ADD_PLUGIN, neu_req_add_plugin_t)                             \
+    XX(NEU_REQ_DEL_PLUGIN, neu_req_del_plugin_t)                             \
+    XX(NEU_REQ_GET_PLUGIN, neu_req_get_plugin_t)                             \
+    XX(NEU_RESP_GET_PLUGIN, neu_resp_get_plugin_t)                           \
+    XX(NEU_REQ_ADD_TEMPLATE, neu_req_add_template_t)                         \
+    XX(NEU_REQ_DEL_TEMPLATE, neu_req_del_template_t)                         \
+    XX(NEU_REQ_GET_TEMPLATE, neu_req_get_template_t)                         \
+    XX(NEU_RESP_GET_TEMPLATE, neu_resp_get_template_t)                       \
+    XX(NEU_REQ_GET_TEMPLATES, neu_req_get_templates_t)                       \
+    XX(NEU_RESP_GET_TEMPLATES, neu_resp_get_templates_t)                     \
+    XX(NEU_REQ_ADD_TEMPLATE_GROUP, neu_req_add_template_group_t)             \
+    XX(NEU_REQ_DEL_TEMPLATE_GROUP, neu_req_del_template_group_t)             \
+    XX(NEU_REQ_UPDATE_TEMPLATE_GROUP, neu_req_update_template_group_t)       \
+    XX(NEU_REQ_GET_TEMPLATE_GROUP, neu_req_get_template_group_t)             \
+    XX(NEU_REQ_ADD_TEMPLATE_TAG, neu_req_add_template_tag_t)                 \
+    XX(NEU_RESP_ADD_TEMPLATE_TAG, neu_resp_add_tag_t)                        \
+    XX(NEU_REQ_DEL_TEMPLATE_TAG, neu_req_del_template_tag_t)                 \
+    XX(NEU_REQ_UPDATE_TEMPLATE_TAG, neu_req_update_template_tag_t)           \
+    XX(NEU_RESP_UPDATE_TEMPLATE_TAG, neu_resp_update_tag_t)                  \
+    XX(NEU_REQ_GET_TEMPLATE_TAG, neu_req_get_template_tag_t)                 \
+    XX(NEU_RESP_GET_TEMPLATE_TAG, neu_resp_get_tag_t)                        \
+    XX(NEU_REQ_INST_TEMPLATE, neu_req_inst_template_t)                       \
+    XX(NEU_REQ_INST_TEMPLATES, neu_req_inst_templates_t)                     \
+    XX(NEU_REQRESP_TRANS_DATA, neu_reqresp_trans_data_t)                     \
+    XX(NEU_REQRESP_NODES_STATE, neu_reqresp_nodes_state_t)                   \
+    XX(NEU_REQRESP_NODE_DELETED, neu_reqresp_node_deleted_t)                 \
+    XX(NEU_REQ_ADD_NDRIVER_MAP, neu_req_ndriver_map_t)                       \
+    XX(NEU_REQ_DEL_NDRIVER_MAP, neu_req_ndriver_map_t)                       \
+    XX(NEU_REQ_GET_NDRIVER_MAPS, neu_req_get_ndriver_maps_t)                 \
+    XX(NEU_RESP_GET_NDRIVER_MAPS, neu_resp_get_ndriver_maps_t)               \
+    XX(NEU_REQ_UPDATE_NDRIVER_TAG_PARAM, neu_req_update_ndriver_tag_param_t) \
+    XX(NEU_REQ_UPDATE_NDRIVER_TAG_INFO, neu_req_update_ndriver_tag_info_t)   \
+    XX(NEU_REQ_GET_NDRIVER_TAGS, neu_req_get_ndriver_tags_t)                 \
+    XX(NEU_RESP_GET_NDRIVER_TAGS, neu_resp_get_ndriver_tags_t)               \
+    XX(NEU_REQ_UPDATE_LOG_LEVEL, neu_req_update_log_level_t)                 \
+    XX(NEU_REQ_ADD_NODE_EVENT, neu_req_add_node_t)                           \
+    XX(NEU_REQ_DEL_NODE_EVENT, neu_req_del_node_t)                           \
+    XX(NEU_REQ_NODE_CTL_EVENT, neu_req_node_ctl_t)                           \
+    XX(NEU_REQ_NODE_SETTING_EVENT, neu_req_node_setting_t)                   \
+    XX(NEU_REQ_ADD_GROUP_EVENT, neu_req_add_group_t)                         \
+    XX(NEU_REQ_DEL_GROUP_EVENT, neu_req_del_group_t)                         \
+    XX(NEU_REQ_UPDATE_GROUP_EVENT, neu_req_update_group_t)                   \
+    XX(NEU_REQ_ADD_TAG_EVENT, neu_req_add_tag_t)                             \
+    XX(NEU_REQ_DEL_TAG_EVENT, neu_req_del_tag_t)                             \
+    XX(NEU_REQ_UPDATE_TAG_EVENT, neu_req_update_tag_t)
+
+static inline size_t neu_reqresp_size(neu_reqresp_type_e t)
+{
+    switch (t) {
+#define XX(type, structure) \
+    case type:              \
+        return sizeof(structure);
+        NEU_REQRESP_TYPE_MAP(XX)
+#undef XX
+    default:
+        assert(false);
+    }
+
+    return 0;
+}
+
+#define XX(type, structure) structure type##_data;
+union neu_reqresp_u {
+    NEU_REQRESP_TYPE_MAP(XX)
+};
+#define NEU_REQRESP_MAX_SIZE sizeof(union neu_reqresp_u)
+#undef XX
+
+struct neu_msg_s {
+    neu_reqresp_head_t head;
+    //  NOTE: we keep the data layout intact only to save refactor efforts.
+    // FIXME: potential alignment problem here.
+    neu_reqresp_head_t body[];
+};
+
+typedef struct neu_msg_s neu_msg_t;
+
+static inline neu_msg_t *neu_msg_new(neu_reqresp_type_e t, void *ctx,
+                                     void *data)
+{
+    size_t data_size = neu_reqresp_size(t);
+
+    // NOTE: ensure enough space to reuse message
+    size_t body_size = 0;
+    switch (t) {
+    case NEU_REQ_GET_PLUGIN:
+        body_size = neu_reqresp_size(NEU_RESP_GET_PLUGIN);
+        break;
+    case NEU_REQ_UPDATE_GROUP:
+    case NEU_REQ_UPDATE_DRIVER_GROUP:
+        body_size = neu_reqresp_size(NEU_RESP_UPDATE_DRIVER_GROUP);
+        break;
+    case NEU_REQ_UPDATE_NODE:
+    case NEU_REQ_NODE_RENAME:
+        body_size = neu_reqresp_size(NEU_RESP_NODE_RENAME);
+        break;
+    case NEU_REQ_DEL_NODE:
+        body_size = neu_reqresp_size(NEU_RESP_NODE_UNINIT);
+        break;
+    case NEU_REQ_GET_NODE_SETTING:
+        body_size = neu_reqresp_size(NEU_RESP_GET_NODE_SETTING);
+        break;
+    case NEU_REQ_GET_NODES_STATE:
+        body_size = neu_reqresp_size(NEU_RESP_GET_NODES_STATE);
+        break;
+    case NEU_REQ_GET_TEMPLATE:
+        body_size = neu_reqresp_size(NEU_RESP_GET_TEMPLATE);
+        break;
+    case NEU_REQ_GET_TEMPLATES:
+        body_size = neu_reqresp_size(NEU_RESP_GET_TEMPLATES);
+        break;
+    case NEU_REQ_READ_GROUP:
+        body_size = neu_reqresp_size(NEU_RESP_READ_GROUP);
+        break;
+    default:
+        body_size = data_size;
+    }
+
+    size_t     total = sizeof(neu_msg_t) + body_size;
+    neu_msg_t *msg   = calloc(1, total);
+    if (msg) {
+        msg->head.type = t;
+        msg->head.len  = total;
+        msg->head.ctx  = ctx;
+        if (data) {
+            memcpy(msg->body, data, data_size);
+        }
+    }
+    return msg;
+}
+
+static inline neu_msg_t *neu_msg_copy(const neu_msg_t *other)
+{
+    neu_msg_t *msg = calloc(1, other->head.len);
+    if (msg) {
+        memcpy(msg, other, other->head.len);
+    }
+    return msg;
+}
+
+static inline void neu_msg_free(neu_msg_t *msg)
+{
+    if (msg) {
+        free(msg);
+    }
+}
+
+static inline size_t neu_msg_size(neu_msg_t *msg)
+{
+    return msg->head.len;
+}
+
+static inline size_t neu_msg_body_size(neu_msg_t *msg)
+{
+    return msg->head.len - sizeof(msg->head);
+}
+
+static inline void *neu_msg_get_header(neu_msg_t *msg)
+{
+    return &msg->head;
+}
+
+static inline void *neu_msg_get_body(neu_msg_t *msg)
+{
+    return &msg->body;
+}
+
+inline static int neu_send_msg(int fd, neu_msg_t *msg)
+{
+    int ret = send(fd, &msg, sizeof(neu_msg_t *), 0);
+    return sizeof(neu_msg_t *) == ret ? 0 : ret;
+}
+
+inline static int neu_recv_msg(int fd, neu_msg_t **msg_p)
+{
+    neu_msg_t *msg = NULL;
+    int        ret = recv(fd, &msg, sizeof(neu_msg_t *), 0);
+    if (sizeof(neu_msg_t *) != ret) {
+        // recv may return 0 bytes
+        return 0 == ret ? -1 : ret;
+    }
+    *msg_p = msg;
+    return 0;
+}
+
+inline static int neu_send_msg_to(int fd, struct sockaddr_in *addr,
+                                  neu_msg_t *msg)
+{
+    int ret = sendto(fd, &msg, sizeof(neu_msg_t *), 0, (struct sockaddr *) addr,
+                     sizeof(*addr));
+    return sizeof(neu_msg_t *) == ret ? 0 : ret;
+}
+
+inline static int neu_recv_msg_from(int fd, struct sockaddr_in *addr,
+                                    neu_msg_t **msg_p)
+{
+    neu_msg_t *msg      = NULL;
+    socklen_t  addr_len = sizeof(struct sockaddr_in);
+    int        ret      = recvfrom(fd, &msg, sizeof(neu_msg_t *), 0,
+                       (struct sockaddr *) addr, &addr_len);
+    if (sizeof(neu_msg_t *) != ret) {
+        // recvfrom may return 0 bytes
+        return 0 == ret ? -1 : ret;
+    }
+    *msg_p = msg;
+    return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/base/neu_plugin_common.c

@@ -31,7 +31,6 @@ void neu_plugin_common_init(neu_plugin_common_t *common)
 {
     common->magic      = NEU_PLUGIN_MAGIC_NUMBER;
     common->link_state = NEU_NODE_LINK_STATE_DISCONNECTED;
-    strcpy(common->log_level, NEU_LOG_LEVEL_NOTICE);
 }
 
 bool neu_plugin_common_check(neu_plugin_t *plugin)

src/connection/connection.c

@@ -347,15 +347,20 @@ ssize_t neu_conn_send(neu_conn_t *conn, uint8_t *buf, ssize_t len)
                     break;
                 }
             } else {
-                if (rc == -1 && errno == EAGAIN) {
-                    if (retry > 5) {
+                if (!conn->block && rc == -1 && errno == EAGAIN) {
+                    if (retry > 10) {
                         zlog_error(conn->param.log,
                                    "conn fd: %d, send buf len: %zd, ret: %zd, "
                                    "errno: %s(%d)",
                                    conn->fd, len, ret, strerror(errno), errno);
                         break;
                     } else {
-                        sleep(1);
+                        struct timespec t1 = {
+                            .tv_sec  = 0,
+                            .tv_nsec = 1000 * 1000 * 50,
+                        };
+                        struct timespec t2 = { 0 };
+                        nanosleep(&t1, &t2);
                         retry++;
                         zlog_warn(conn->param.log,
                                   "not all data send, retry: %d, ret: "
@@ -442,11 +447,21 @@ ssize_t neu_conn_recv(neu_conn_t *conn, uint8_t *buf, ssize_t len)
                 conn->fd, len, ret, strerror(errno), errno);
             conn_disconnect(conn);
         }
+    } else if (conn->param.type == NEU_CONN_UDP ||
+               conn->param.type == NEU_CONN_UDP_TO) {
+        if (ret <= 0) {
+            zlog_error(
+                conn->param.log,
+                "udp conn fd: %d, recv buf len %zd, ret: %zd, errno: %s(%d)",
+                conn->fd, len, ret, strerror(errno), errno);
+            conn_disconnect(conn);
+        }
     } else {
         if (ret <= 0) {
-            zlog_error(conn->param.log,
-                       "conn fd: %d, recv buf len %zd, ret: %zd, errno: %s(%d)",
-                       conn->fd, len, ret, strerror(errno), errno);
+            zlog_error(
+                conn->param.log,
+                "tcp conn fd: %d, recv buf len %zd, ret: %zd, errno: %s(%d)",
+                conn->fd, len, ret, strerror(errno), errno);
             if (ret == 0 || (ret == -1 && errno != EAGAIN)) {
                 conn_disconnect(conn);
             }
@@ -815,7 +830,14 @@ static void conn_connect(neu_conn_t *conn)
             return;
         }
 
-        if (ret != 0 && errno != EINPROGRESS) {
+        if ((conn->block && ret == 0) ||
+            (!conn->block && ret != 0 && errno == EINPROGRESS)) {
+            zlog_notice(conn->param.log, "connect %s:%d success",
+                        conn->param.params.tcp_client.ip,
+                        conn->param.params.tcp_client.port);
+            conn->is_connected = true;
+            conn->fd           = fd;
+        } else {
             close(fd);
             zlog_error(conn->param.log, "connect %s:%d error: %s(%d)",
                        conn->param.params.tcp_client.ip,
@@ -823,13 +845,8 @@ static void conn_connect(neu_conn_t *conn)
                        errno);
             conn->is_connected = false;
             return;
-        } else {
-            zlog_notice(conn->param.log, "connect %s:%d success",
-                        conn->param.params.tcp_client.ip,
-                        conn->param.params.tcp_client.port);
-            conn->is_connected = true;
-            conn->fd           = fd;
         }
+
         break;
     }
     case NEU_CONN_UDP: {

src/core/manager.c

@@ -32,6 +32,7 @@
 #include "adapter.h"
 #include "adapter/adapter_internal.h"
 #include "adapter/driver/driver_internal.h"
+#include "base/msg_internal.h"
 #include "errcodes.h"
 
 #include "node_manager.h"
@@ -51,6 +52,9 @@ inline static void reply(neu_manager_t *manager, neu_reqresp_head_t *header,
                          void *data);
 inline static void forward_msg(neu_manager_t *     manager,
                                neu_reqresp_head_t *header, const char *node);
+inline static void forward_msg_copy(neu_manager_t *     manager,
+                                    neu_reqresp_head_t *header,
+                                    const char *        node);
 
 // inline static nng_msg *trans_data_dup(nng_msg *msg);
 // inline static void     trans_data_free(nng_msg *msg);
@@ -92,6 +96,7 @@ neu_manager_t *neu_manager_create()
     manager->node_manager      = neu_node_manager_create();
     manager->subscribe_manager = neu_subscribe_manager_create();
     manager->template_manager  = neu_template_manager_create();
+    manager->log_level         = ZLOG_LEVEL_NOTICE;
 
     manager->server_fd =
         socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
@@ -149,26 +154,21 @@ neu_manager_t *neu_manager_create()
 
 void neu_manager_destroy(neu_manager_t *manager)
 {
-    memset(manager->buf, 0, sizeof(manager->buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) manager->buf;
     neu_req_node_init_t uninit = { 0 };
 
     UT_array *addrs = neu_node_manager_get_addrs_all(manager->node_manager);
 
-    neu_event_del_timer(manager->events, manager->timer_lev);
     neu_event_del_timer(manager->events, manager->timer_timestamp);
 
-    header->type = NEU_REQ_NODE_UNINIT;
-    strcpy(header->sender, "manager");
-
     utarray_foreach(addrs, struct sockaddr_in *, addr)
     {
-        neu_msg_gen(header, &uninit);
-        if (sendto(manager->server_fd, manager->buf, header->len, 0,
-                   (struct sockaddr *) addr,
-                   sizeof(struct sockaddr_in)) != (int) header->len) {
+        neu_msg_t *msg = neu_msg_new(NEU_REQ_NODE_UNINIT, NULL, &uninit);
+        neu_reqresp_head_t *header = neu_msg_get_header(msg);
+        strcpy(header->sender, "manager");
+        if (0 != neu_send_msg_to(manager->server_fd, addr, msg)) {
             nlog_error("manager -> %s uninit msg send fail",
                        inet_ntoa((*addr).sin_addr));
+            neu_msg_free(msg);
         }
     }
     utarray_free(addrs);
@@ -197,8 +197,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 {
     int                 rv       = 0;
     neu_manager_t *     manager  = (neu_manager_t *) usr_data;
-    socklen_t           addr_len = sizeof(struct sockaddr_in);
     struct sockaddr_in  src_addr = { 0 };
+    neu_msg_t *         msg      = NULL;
     neu_reqresp_head_t *header   = NULL;
 
     if (type == NEU_EVENT_IO_CLOSED || type == NEU_EVENT_IO_HUP) {
@@ -206,16 +206,13 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         return 0;
     }
 
-    memset(manager->recv_buf, 0, sizeof(manager->recv_buf));
-    rv = recvfrom(manager->server_fd, manager->recv_buf,
-                  sizeof(manager->recv_buf), 0, (struct sockaddr *) &src_addr,
-                  &addr_len);
+    rv = neu_recv_msg_from(manager->server_fd, &src_addr, &msg);
     if (rv == -1) {
         nlog_warn("manager recv msg error: %s(%d)", strerror(errno), errno);
         return 0;
     }
 
-    header = (neu_reqresp_head_t *) manager->recv_buf;
+    header = neu_msg_get_header(msg);
 
     nlog_info("manager recv msg from: %s to %s, type: %s", header->sender,
               header->receiver, neu_reqresp_type_string(header->type));
@@ -228,6 +225,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                                     src_addr)) {
             nlog_warn("bind node %s to src addr(%d) fail", init->node,
                       ntohs(src_addr.sin_port));
+            neu_msg_free(msg);
             break;
         }
 
@@ -243,6 +241,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         nlog_notice("bind node %s to src addr(%d)", init->node,
                     ntohs(src_addr.sin_port));
+        neu_msg_free(msg);
         break;
     }
     case NEU_REQ_ADD_PLUGIN: {
@@ -601,22 +600,42 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         manager_storage_del_node(manager, cmd->node);
         if (neu_adapter_get_type(adapter) == NEU_NA_TYPE_APP) {
+            UT_array *subscriptions = neu_subscribe_manager_get(
+                manager->subscribe_manager, cmd->node);
             neu_subscribe_manager_unsub_all(manager->subscribe_manager,
                                             cmd->node);
+
+            utarray_foreach(subscriptions, neu_resp_subscribe_info_t *, sub)
+            {
+                // NOTE: neu_req_unsubscribe_t and neu_resp_subscribe_info_t
+                //       have compatible memory layout
+                msg = neu_msg_new(NEU_REQ_UNSUBSCRIBE_GROUP, NULL, sub);
+                if (NULL == msg) {
+                    break;
+                }
+                neu_reqresp_head_t *hd = neu_msg_get_header(msg);
+                strcpy(hd->receiver, sub->driver);
+                strcpy(hd->sender, "manager");
+                forward_msg(manager, hd, hd->receiver);
+            }
+            utarray_free(subscriptions);
         }
+        notify_monitors(manager, NEU_REQ_DEL_NODE_EVENT, cmd);
+        neu_reqresp_node_deleted_t resp = { 0 };
+        strcpy(resp.node, header->receiver);
         header->type = NEU_REQ_NODE_UNINIT;
         forward_msg(manager, header, header->receiver);
-        notify_monitors(manager, NEU_REQ_DEL_NODE_EVENT, cmd);
         if (neu_adapter_get_type(adapter) == NEU_NA_TYPE_DRIVER) {
             UT_array *apps = neu_subscribe_manager_find_by_driver(
-                manager->subscribe_manager, cmd->node);
+                manager->subscribe_manager, resp.node);
 
             utarray_foreach(apps, neu_app_subscribe_t *, app)
             {
-                neu_reqresp_node_deleted_t resp = { 0 };
-                header->type                    = NEU_REQRESP_NODE_DELETED;
-
-                strcpy(resp.node, header->receiver);
+                msg = neu_msg_new(NEU_REQRESP_NODE_DELETED, NULL, &resp);
+                if (NULL == msg) {
+                    break;
+                }
+                header = neu_msg_get_header(msg);
                 strcpy(header->receiver, app->app_name);
                 strcpy(header->sender, "manager");
                 reply(manager, header, &resp);
@@ -635,6 +654,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_resp_error_t error = { 0 };
             header->type           = NEU_RESP_ERROR;
             reply(manager, header, &error);
+        } else {
+            neu_msg_free(msg);
         }
         break;
     }
@@ -659,8 +680,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (error.error == NEU_ERR_SUCCESS) {
             cmd->port = app_port;
-            forward_msg(manager, header, cmd->app);
-            forward_msg(manager, header, cmd->driver);
+            forward_msg_copy(manager, header, cmd->app);
+            forward_msg_copy(manager, header, cmd->driver);
             manager_storage_subscribe(manager, cmd->app, cmd->driver,
                                       cmd->group, cmd->params);
         } else {
@@ -712,7 +733,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             manager, cmd->app, cmd->driver, cmd->group, cmd->params);
 
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, header, cmd->app);
+            forward_msg_copy(manager, header, cmd->app);
             manager_storage_update_subscribe(manager, cmd->app, cmd->driver,
                                              cmd->group, cmd->params);
         } else {
@@ -732,8 +753,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_manager_unsubscribe(manager, cmd->app, cmd->driver, cmd->group);
 
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, header, cmd->app);
-            forward_msg(manager, header, cmd->driver);
+            forward_msg_copy(manager, header, cmd->app);
+            forward_msg_copy(manager, header, cmd->driver);
             manager_storage_unsubscribe(manager, cmd->app, cmd->driver,
                                         cmd->group);
         }
@@ -788,7 +809,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_get_nodes_state_t resp = { 0 };
         UT_array *states = neu_node_manager_get_state(manager->node_manager);
 
-        resp.states = utarray_clone(states);
+        resp.core_level = manager->log_level;
+        resp.states     = utarray_clone(states);
 
         strcpy(header->receiver, header->sender);
         strcpy(header->sender, "manager");
@@ -813,14 +835,37 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
     case NEU_REQ_GET_GROUP:
     case NEU_REQ_GET_NODE_SETTING:
-    case NEU_REQ_GET_NODE_STATE:
     case NEU_REQ_READ_GROUP:
     case NEU_REQ_WRITE_TAG:
     case NEU_REQ_WRITE_TAGS:
+    case NEU_REQ_WRITE_GTAGS:
     case NEU_REQ_GET_TAG:
     case NEU_REQ_GET_NDRIVER_TAGS:
     case NEU_REQ_NODE_CTL:
     case NEU_REQ_ADD_GROUP: {
+        if (neu_node_manager_find(manager->node_manager, header->receiver) ==
+            NULL) {
+            if (NEU_REQ_READ_GROUP == header->type) {
+                neu_req_read_group_fini((neu_req_read_group_t *) &header[1]);
+            } else if (NEU_REQ_WRITE_TAG == header->type) {
+                neu_req_write_tag_fini((neu_req_write_tag_t *) &header[1]);
+            } else if (NEU_REQ_WRITE_TAGS == header->type) {
+                neu_req_write_tags_fini((neu_req_write_tags_t *) &header[1]);
+            } else if (NEU_REQ_WRITE_GTAGS == header->type) {
+                neu_req_write_gtags_fini((neu_req_write_gtags_t *) &header[1]);
+            }
+            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
+            header->type       = NEU_RESP_ERROR;
+            neu_msg_exchange(header);
+            reply(manager, header, &e);
+        } else {
+            forward_msg(manager, header, header->receiver);
+        }
+
+        break;
+    }
+
+    case NEU_REQ_GET_NODE_STATE: {
         if (neu_node_manager_find(manager->node_manager, header->receiver) ==
             NULL) {
             neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
@@ -849,7 +894,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                 utarray_foreach(apps, neu_app_subscribe_t *, app)
                 {
                     header->type = NEU_REQ_UPDATE_NODE;
-                    forward_msg(manager, header, app->app_name);
+                    forward_msg_copy(manager, header, app->app_name);
                 }
 
                 utarray_free(apps);
@@ -876,7 +921,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                 utarray_foreach(apps, neu_app_subscribe_t *, app)
                 {
                     header->type = NEU_REQ_UPDATE_GROUP;
-                    forward_msg(manager, header, app->app_name);
+                    forward_msg_copy(manager, header, app->app_name);
                 }
 
                 utarray_free(apps);
@@ -900,6 +945,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_DEL_TAG_EVENT:
     case NEU_REQ_UPDATE_TAG_EVENT: {
         notify_monitors(manager, header->type, &header[1]);
+        neu_msg_free(msg);
         break;
     }
 
@@ -936,9 +982,24 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(manager, header, &e);
         } else {
+            UT_array *apps = neu_subscribe_manager_find(
+                manager->subscribe_manager, cmd->driver, cmd->group);
+
             forward_msg(manager, header, header->receiver);
             neu_subscribe_manager_remove(manager->subscribe_manager,
                                          cmd->driver, cmd->group);
+
+            if (NULL == apps) {
+                break;
+            }
+
+            // notify app node about group deletion
+            utarray_foreach(apps, neu_app_subscribe_t *, app)
+            {
+                forward_msg_copy(manager, header, app->app_name);
+            }
+
+            utarray_free(apps);
         }
         break;
     }
@@ -947,14 +1008,14 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (neu_node_manager_find(manager->node_manager, header->receiver) ==
             NULL) {
-            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
-            header->type       = NEU_RESP_ERROR;
-            neu_msg_exchange(header);
-            reply(manager, header, &e);
             for (int i = 0; i < cmd->n_tag; i++) {
                 free(cmd->tags[i]);
             }
             free(cmd->tags);
+            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
+            header->type       = NEU_RESP_ERROR;
+            neu_msg_exchange(header);
+            reply(manager, header, &e);
         } else {
             forward_msg(manager, header, header->receiver);
         }
@@ -967,14 +1028,14 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (neu_node_manager_find(manager->node_manager, header->receiver) ==
             NULL) {
-            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
-            header->type       = NEU_RESP_ERROR;
-            neu_msg_exchange(header);
-            reply(manager, header, &e);
             for (int i = 0; i < cmd->n_tag; i++) {
                 neu_tag_fini(&cmd->tags[i]);
             }
             free(cmd->tags);
+            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
+            header->type       = NEU_RESP_ERROR;
+            neu_msg_exchange(header);
+            reply(manager, header, &e);
         } else {
             forward_msg(manager, header, header->receiver);
         }
@@ -986,11 +1047,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (neu_node_manager_find(manager->node_manager, header->receiver) ==
             NULL) {
+            free(cmd->setting);
             neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
             header->type       = NEU_RESP_ERROR;
             neu_msg_exchange(header);
             reply(manager, header, &e);
-            free(cmd->setting);
         } else {
             forward_msg(manager, header, header->receiver);
         }
@@ -1006,12 +1067,19 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_RESP_GET_NDRIVER_TAGS:
     case NEU_RESP_GET_GROUP:
     case NEU_RESP_GET_NODE_SETTING:
-    case NEU_RESP_GET_NODE_STATE:
     case NEU_RESP_ERROR:
     case NEU_RESP_READ_GROUP:
         forward_msg(manager, header, header->receiver);
         break;
 
+    case NEU_RESP_GET_NODE_STATE: {
+        neu_resp_get_node_state_t *resp =
+            (neu_resp_get_node_state_t *) &header[1];
+
+        resp->core_level = manager->log_level;
+        forward_msg(manager, header, header->receiver);
+        break;
+    }
     case NEU_REQ_ADD_NDRIVER_MAP: {
         neu_req_ndriver_map_t *cmd   = (neu_req_ndriver_map_t *) &header[1];
         neu_resp_error_t       error = { 0 };
@@ -1019,7 +1087,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         error.error = neu_manager_add_ndriver_map(manager, cmd->ndriver,
                                                   cmd->driver, cmd->group);
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, header, cmd->ndriver);
+            forward_msg_copy(manager, header, cmd->ndriver);
             manager_storage_add_ndriver_map(manager, cmd->ndriver, cmd->driver,
                                             cmd->group);
         }
@@ -1036,7 +1104,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         error.error = neu_manager_del_ndriver_map(manager, cmd->ndriver,
                                                   cmd->driver, cmd->group);
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, header, cmd->ndriver);
+            forward_msg_copy(manager, header, cmd->ndriver);
             manager_storage_del_ndriver_map(manager, cmd->ndriver, cmd->driver,
                                             cmd->group);
         }
@@ -1088,25 +1156,34 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         }
         break;
     }
-    case NEU_REQ_UPDATE_LOG_LEVEL:
-        if (neu_node_manager_find(manager->node_manager, header->receiver) ==
-            NULL) {
-            neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
+    case NEU_REQ_UPDATE_LOG_LEVEL: {
+        neu_req_update_log_level_t *cmd =
+            (neu_req_update_log_level_t *) &header[1];
+
+        if (cmd->core) {
+            manager->log_level = cmd->log_level;
+            nlog_level_change(manager->log_level);
+        }
+
+        if (strlen(cmd->node) > 0) {
+            if (neu_node_manager_find(manager->node_manager,
+                                      header->receiver) == NULL) {
+                neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST };
+                header->type       = NEU_RESP_ERROR;
+                neu_msg_exchange(header);
+                reply(manager, header, &e);
+            } else {
+                forward_msg(manager, header, header->receiver);
+            }
+        } else {
+            neu_resp_error_t e = { .error = NEU_ERR_SUCCESS };
             header->type       = NEU_RESP_ERROR;
             neu_msg_exchange(header);
             reply(manager, header, &e);
-        } else {
-            neu_req_update_log_level_t *cmd =
-                (neu_req_update_log_level_t *) &header[1];
-            neu_adapter_t *adapter_log =
-                neu_node_manager_find(manager->node_manager, header->receiver);
-            strcpy(neu_plugin_to_plugin_common(adapter_log->plugin)->log_level,
-                   cmd->log_level);
-
-            forward_msg(manager, header, header->receiver);
         }
 
         break;
+    }
     default:
         assert(false);
         break;
@@ -1121,18 +1198,29 @@ inline static void forward_msg(neu_manager_t *     manager,
     struct sockaddr_in addr =
         neu_node_manager_get_addr(manager->node_manager, node);
 
-    int ret = sendto(manager->server_fd, header, header->len, 0,
-                     (struct sockaddr *) &addr, sizeof(addr));
-    if (ret != (int) header->len) {
-        nlog_warn("forward msg %s to node (%s)%d fail",
-                  neu_reqresp_type_string(header->type), node,
-                  ntohs(addr.sin_port));
+    neu_reqresp_type_e t                           = header->type;
+    char               receiver[NEU_NODE_NAME_LEN] = { 0 };
+    strncpy(receiver, header->receiver, sizeof(receiver));
+
+    neu_msg_t *msg = (neu_msg_t *) header;
+    int        ret = neu_send_msg_to(manager->server_fd, &addr, msg);
+    if (0 == ret) {
+        nlog_info("forward msg %s to %s", neu_reqresp_type_string(t), receiver);
     } else {
-        nlog_info("forward msg %s to %s", neu_reqresp_type_string(header->type),
-                  node);
+        nlog_warn("forward msg %s to node (%s)%d fail",
+                  neu_reqresp_type_string(t), receiver, ntohs(addr.sin_port));
+        neu_msg_free(msg);
     }
 }
 
+inline static void forward_msg_copy(neu_manager_t *     manager,
+                                    neu_reqresp_head_t *header,
+                                    const char *        node)
+{
+    neu_msg_t *msg = neu_msg_copy((neu_msg_t *) header);
+    forward_msg(manager, neu_msg_get_header(msg), node);
+}
+
 struct notify_monitor_ctx {
     neu_manager_t *    manager;
     neu_reqresp_type_e event;
@@ -1152,10 +1240,21 @@ static int notify_monitor(const char *name, struct sockaddr_in addr, void *arg)
         return 0;
     }
 
+    // message header
+    neu_msg_t *msg = neu_msg_new(ctx->event, NULL, data);
+    if (NULL == msg) {
+        return -1;
+    }
+
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
+    strcpy(header->sender, "manager");
+    strcpy(header->receiver, name);
+
     // copy message data
     switch (ctx->event) {
     case NEU_REQ_NODE_SETTING_EVENT: {
         if (0 != neu_req_node_setting_copy(&setting, ctx->data)) {
+            neu_msg_free(msg);
             return -1;
         }
         data = &setting;
@@ -1164,6 +1263,7 @@ static int notify_monitor(const char *name, struct sockaddr_in addr, void *arg)
     case NEU_REQ_ADD_TAG_EVENT:
     case NEU_REQ_UPDATE_TAG_EVENT: {
         if (0 != neu_req_add_tag_copy(&mod_tag, ctx->data)) {
+            neu_msg_free(msg);
             return -1;
         }
         data = &mod_tag;
@@ -1171,6 +1271,7 @@ static int notify_monitor(const char *name, struct sockaddr_in addr, void *arg)
     }
     case NEU_REQ_DEL_TAG_EVENT: {
         if (0 != neu_req_del_tag_copy(&del_tag, ctx->data)) {
+            neu_msg_free(msg);
             return -1;
         }
         data = &del_tag;
@@ -1180,23 +1281,12 @@ static int notify_monitor(const char *name, struct sockaddr_in addr, void *arg)
         data = ctx->data;
     }
 
-    // message header
-    memset(ctx->manager->buf, 0, sizeof(ctx->manager->buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) ctx->manager->buf;
-
-    strcpy(header->sender, "manager");
-    strcpy(header->receiver, name);
-    header->type = ctx->event;
-
-    // send message
-    neu_msg_gen(header, data);
-
-    int ret = sendto(ctx->manager->server_fd, header, header->len, 0,
-                     (struct sockaddr *) &addr, sizeof(addr));
-    if (ret <= 0) {
+    int ret = neu_send_msg_to(ctx->manager->server_fd, &addr, msg);
+    if (0 != ret) {
         nlog_warn("notify %s of %s, error: %s(%d)", header->receiver,
                   neu_reqresp_type_string(header->type), strerror(errno),
                   errno);
+        neu_msg_free(msg);
     }
 
     return 0;
@@ -1277,16 +1367,20 @@ inline static void reply(neu_manager_t *manager, neu_reqresp_head_t *header,
     struct sockaddr_in addr =
         neu_node_manager_get_addr(manager->node_manager, header->receiver);
 
-    int ret = sendto(manager->server_fd, header, header->len, 0,
-                     (struct sockaddr *) &addr, sizeof(addr));
+    neu_reqresp_type_e t                           = header->type;
+    void *             ctx                         = header->ctx;
+    char               receiver[NEU_NODE_NAME_LEN] = { 0 };
+    strncpy(receiver, header->receiver, sizeof(receiver));
 
-    if (ret != (int) header->len) {
-        nlog_warn("reply %s to %s, error: %d",
-                  neu_reqresp_type_string(header->type), header->receiver, ret);
+    neu_msg_t *msg = (neu_msg_t *) header;
+    int        ret = neu_send_msg_to(manager->server_fd, &addr, msg);
+    if (0 == ret) {
+        nlog_notice("reply %s to %s(%d) %p", neu_reqresp_type_string(t),
+                    receiver, ntohs(addr.sin_port), ctx);
     } else {
-        nlog_notice("reply %s to %s(%d) %p",
-                    neu_reqresp_type_string(header->type), header->receiver,
-                    ntohs(addr.sin_port), header->ctx);
+        nlog_warn("reply %s to %s, error: %d", neu_reqresp_type_string(t),
+                  receiver, ret);
+        neu_msg_free(msg);
     }
 }
 
@@ -1295,4 +1389,4 @@ static int update_timestamp(void *usr_data)
     (void) usr_data;
     global_timestamp = neu_time_ms();
     return 0;
-}
+}

src/core/manager_internal.c

@@ -26,6 +26,7 @@
 
 #include "adapter/adapter_internal.h"
 #include "adapter/driver/driver_internal.h"
+#include "base/msg_internal.h"
 
 #include "manager_internal.h"
 #include "template_manager.h"
@@ -702,7 +703,6 @@ int neu_manager_subscribe(neu_manager_t *manager, const char *app,
     // this is not an elegant solution due to the current architecture
     if (params && 0 == strcmp(adapter->module->module_name, "MQTT")) {
         neu_json_elem_t elem = { .name = "topic", .t = NEU_JSON_STR };
-        neu_json_decode((char *) params, 1, &elem);
         neu_parse_param(params, NULL, 1, &elem);
         if (elem.v.val_str && 0 == strlen(elem.v.val_str)) {
             free(elem.v.val_str);
@@ -730,12 +730,6 @@ int neu_manager_send_subscribe(neu_manager_t *manager, const char *app,
                                const char *driver, const char *group,
                                uint16_t app_port, const char *params)
 {
-    memset(manager->buf, 0, sizeof(manager->buf));
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) manager->buf;
-    header->type               = NEU_REQ_SUBSCRIBE_GROUP;
-    strcpy(header->sender, "manager");
-    strcpy(header->receiver, app);
-
     neu_req_subscribe_t cmd = { 0 };
     strcpy(cmd.app, app);
     strcpy(cmd.driver, driver);
@@ -746,35 +740,47 @@ int neu_manager_send_subscribe(neu_manager_t *manager, const char *app,
         return NEU_ERR_EINTERNAL;
     }
 
+    neu_msg_t *msg = neu_msg_new(NEU_REQ_SUBSCRIBE_GROUP, NULL, &cmd);
+    if (NULL == msg) {
+        free(cmd.params);
+        return NEU_ERR_EINTERNAL;
+    }
+    neu_reqresp_head_t *header = neu_msg_get_header(msg);
+    strcpy(header->sender, "manager");
+    strcpy(header->receiver, app);
+
     struct sockaddr_in addr =
         neu_node_manager_get_addr(manager->node_manager, app);
 
-    neu_msg_gen(header, &cmd);
-
-    int ret = sendto(manager->server_fd, header, header->len, 0,
-                     (struct sockaddr *) &addr, sizeof(addr));
-    if (ret != (int) header->len) {
+    int ret = neu_send_msg_to(manager->server_fd, &addr, msg);
+    if (0 != ret) {
         nlog_warn("send %s to %s app failed",
-                  neu_reqresp_type_string(header->type), app);
+                  neu_reqresp_type_string(NEU_REQ_SUBSCRIBE_GROUP), app);
         free(cmd.params);
+        neu_msg_free(msg);
     } else {
-        nlog_notice("send %s to %s app", neu_reqresp_type_string(header->type),
-                    app);
+        nlog_notice("send %s to %s app",
+                    neu_reqresp_type_string(NEU_REQ_SUBSCRIBE_GROUP), app);
     }
+    cmd.params = NULL;
 
+    msg = neu_msg_new(NEU_REQ_SUBSCRIBE_GROUP, NULL, &cmd);
+    if (NULL == msg) {
+        return NEU_ERR_EINTERNAL;
+    }
+    header = neu_msg_get_header(msg);
+    strcpy(header->sender, "manager");
     strcpy(header->receiver, driver);
     addr = neu_node_manager_get_addr(manager->node_manager, driver);
 
-    neu_msg_gen(header, &cmd);
-
-    ret = sendto(manager->server_fd, header, header->len, 0,
-                 (struct sockaddr *) &addr, sizeof(addr));
-    if (ret != (int) header->len) {
+    ret = neu_send_msg_to(manager->server_fd, &addr, msg);
+    if (0 != ret) {
         nlog_warn("send %s to %s driver failed",
-                  neu_reqresp_type_string(header->type), app);
+                  neu_reqresp_type_string(NEU_REQ_SUBSCRIBE_GROUP), driver);
+        neu_msg_free(msg);
     } else {
         nlog_notice("send %s to %s driver",
-                    neu_reqresp_type_string(header->type), app);
+                    neu_reqresp_type_string(NEU_REQ_SUBSCRIBE_GROUP), driver);
     }
 
     return 0;

src/core/manager_internal.h

@@ -29,9 +29,8 @@
 #include "template_manager.h"
 
 typedef struct neu_manager {
-    int             server_fd;
-    uint8_t         buf[NEU_MSG_MAX_SIZE];
-    uint8_t         recv_buf[NEU_MSG_MAX_SIZE];
+    int server_fd;
+
     neu_events_t *  events;
     neu_event_io_t *loop;
 
@@ -42,8 +41,9 @@ typedef struct neu_manager {
 
     neu_event_timer_t *timer_timestamp;
 
-    neu_event_timer_t *timer_lev;
-    int64_t            timestamp_lev_manager;
+    int64_t timestamp_lev_manager;
+
+    int log_level;
 } neu_manager_t;
 
 int       neu_manager_add_plugin(neu_manager_t *manager, const char *library);

src/core/node_manager.c

@@ -414,8 +414,7 @@ UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr)
             state.state.running = el->adapter->state;
             state.state.link =
                 neu_plugin_to_plugin_common(el->adapter->plugin)->link_state;
-            strcpy(state.state.log_level,
-                   neu_plugin_to_plugin_common(el->adapter->plugin)->log_level);
+            state.state.log_level = el->adapter->log_level;
             neu_metric_entry_t *e = NULL;
             if (NULL != el->adapter->metrics) {
                 HASH_FIND_STR(el->adapter->metrics->entries,

src/daemon.c

@@ -149,9 +149,14 @@ int neuron_already_running()
     fd = open(NEURON_DAEMON_LOCK_FNAME, O_RDWR | O_CREAT,
               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
     if (fd < 0) {
-        nlog_error("cannot open %s reason: %s\n", NEURON_DAEMON_LOCK_FNAME,
-                   strerror(errno));
-        exit(1);
+        // work around fs.protected_regular
+        fd = open(NEURON_DAEMON_LOCK_FNAME, O_RDWR,
+                  S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+        if (fd < 0) {
+            nlog_error("cannot open %s reason: %s\n", NEURON_DAEMON_LOCK_FNAME,
+                       strerror(errno));
+            exit(1);
+        }
     }
 
     // try to lock file

src/event/event_linux.c

@@ -66,6 +66,8 @@ struct event_data {
     bool  use;
 };
 
+#define EVENT_SIZE 1400
+
 struct neu_events {
     int       epoll_fd;
     pthread_t thread;
@@ -73,14 +75,14 @@ struct neu_events {
 
     pthread_mutex_t   mtx;
     int               n_event;
-    struct event_data event_datas[256];
+    struct event_data event_datas[EVENT_SIZE];
 };
 
 static int get_free_event(neu_events_t *events)
 {
     int ret = -1;
     pthread_mutex_lock(&events->mtx);
-    for (int i = 0; i < 256; i++) {
+    for (int i = 0; i < EVENT_SIZE; i++) {
         if (events->event_datas[i].use == false) {
             events->event_datas[i].use   = true;
             events->event_datas[i].index = i;
@@ -180,8 +182,12 @@ neu_events_t *neu_event_new(void)
     neu_events_t *events = calloc(1, sizeof(struct neu_events));
 
     events->epoll_fd = epoll_create(1);
-    events->stop     = false;
-    events->n_event  = 0;
+
+    nlog_notice("create epoll: %d(%d)", events->epoll_fd, errno);
+    assert(events->epoll_fd > 0);
+
+    events->stop    = false;
+    events->n_event = 0;
     pthread_mutex_init(&events->mtx, NULL);
 
     pthread_create(&events->thread, NULL, event_loop, events);
@@ -213,6 +219,9 @@ neu_event_timer_t *neu_event_add_timer(neu_events_t *          events,
         .it_interval.tv_nsec = timer.millisecond * 1000 * 1000,
     };
     int index = get_free_event(events);
+    if (index < 0) {
+        zlog_notice(neuron, "no free event: %d", events->epoll_fd);
+    }
     assert(index >= 0);
 
     neu_event_timer_t *timer_ctx = &events->event_datas[index].ctx.timer;
@@ -230,6 +239,7 @@ neu_event_timer_t *neu_event_add_timer(neu_events_t *          events,
     timer_ctx->event_data->usr_data       = timer.usr_data;
     timer_ctx->event_data->callback.timer = timer.cb;
     timer_ctx->event_data->ctx.timer = events->event_datas[index].ctx.timer;
+    timer_ctx->event_data->index     = index;
 
     timer_ctx->value = value;
     timer_ctx->fd    = timer_fd;
@@ -242,17 +252,17 @@ neu_event_timer_t *neu_event_add_timer(neu_events_t *          events,
     zlog_notice(neuron,
                 "add timer, second: %" PRId64 ", millisecond: %" PRId64
                 ", timer: %d in epoll %d, "
-                "ret: %d",
+                "ret: %d, index: %d",
                 timer.second, timer.millisecond, timer_fd, events->epoll_fd,
-                ret);
+                ret, index);
 
     return timer_ctx;
 }
 
 int neu_event_del_timer(neu_events_t *events, neu_event_timer_t *timer)
 {
-    zlog_notice(neuron, "del timer: %d from epoll: %d", timer->fd,
-                events->epoll_fd);
+    zlog_notice(neuron, "del timer: %d from epoll: %d, index: %d", timer->fd,
+                events->epoll_fd, timer->event_data->index);
 
     timer->stop = true;
     epoll_ctl(events->epoll_fd, EPOLL_CTL_DEL, timer->fd, NULL);
@@ -268,8 +278,13 @@ int neu_event_del_timer(neu_events_t *events, neu_event_timer_t *timer)
 
 neu_event_io_t *neu_event_add_io(neu_events_t *events, neu_event_io_param_t io)
 {
-    int             ret      = 0;
-    int             index    = get_free_event(events);
+    int ret   = 0;
+    int index = get_free_event(events);
+
+    nlog_notice("add io, fd: %d, epoll: %d, index: %d", io.fd, events->epoll_fd,
+                index);
+    assert(index >= 0);
+
     neu_event_io_t *io_ctx   = &events->event_datas[index].ctx.io;
     io_ctx->event_data       = &events->event_datas[index];
     struct epoll_event event = {
@@ -282,13 +297,15 @@ neu_event_io_t *neu_event_add_io(neu_events_t *events, neu_event_io_param_t io)
     io_ctx->event_data->usr_data    = io.usr_data;
     io_ctx->event_data->callback.io = io.cb;
     io_ctx->event_data->ctx.io      = events->event_datas[index].ctx.io;
+    io_ctx->event_data->index       = index;
 
     io_ctx->fd = io.fd;
 
     ret = epoll_ctl(events->epoll_fd, EPOLL_CTL_ADD, io.fd, &event);
 
-    nlog_notice("add io, fd: %d, epoll: %d, ret: %d", io.fd, events->epoll_fd,
-                ret);
+    nlog_notice("add io, fd: %d, epoll: %d, ret: %d(%d), index: %d", io.fd,
+                events->epoll_fd, ret, errno, index);
+    assert(ret == 0);
 
     return io_ctx;
 }
@@ -299,7 +316,8 @@ int neu_event_del_io(neu_events_t *events, neu_event_io_t *io)
         return 0;
     }
 
-    zlog_notice(neuron, "del io: %d from epoll: %d", io->fd, events->epoll_fd);
+    zlog_notice(neuron, "del io: %d from epoll: %d, index: %d", io->fd,
+                events->epoll_fd, io->event_data->index);
 
     epoll_ctl(events->epoll_fd, EPOLL_CTL_DEL, io->fd, NULL);
     free_event(events, io->event_data->index);

src/main.c

@@ -62,8 +62,31 @@ static void sig_handler(int sig)
     exit(-1);
 }
 
+static inline char syslog_priority(const char *level)
+{
+    switch (level[0]) {
+    case 'D': // DEBUG
+        return '7';
+    case 'I': // INFO
+        return '6';
+    case 'N': // NOTICE
+        return '5';
+    case 'W': // WARN
+        return '4';
+    case 'E': // ERROR
+        return '3';
+    case 'F': // FATAL
+        return '2';
+    default: // UNKNOWN
+        return '1';
+    }
+}
+
 static int remote_syslog(zlog_msg_t *msg)
 {
+    // fix priority
+    msg->buf[1] = syslog_priority(msg->path);
+
     sendto(g_remote_syslog_ctx.fd, msg->buf, msg->len, 0,
            (const struct sockaddr *) &g_remote_syslog_ctx.addr,
            sizeof(g_remote_syslog_ctx.addr));
@@ -102,9 +125,10 @@ static int neuron_run(const neu_cli_args_t *args)
     int           rv = 0;
 
     signal(SIGINT, sig_handler);
-    signal(SIGTERM, sig_handler);
     signal(SIGABRT, sig_handler);
     signal(SIGSEGV, sig_handler);
+    signal(SIGTERM, sig_handler);
+    signal(SIGKILL, sig_handler);
 
     // try to enable core dump
     rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;

src/parser/neu_json_file.c

@@ -1,81 +0,0 @@
-/**
- * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- **/
-
-/*
- * DO NOT EDIT THIS FILE MANUALLY!
- * It was automatically generated by `json-autotype`.
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "json/json.h"
-
-#include "neu_json_file.h"
-
-int neu_json_encode_get_file_list_resp(void *json_object, void *param)
-{
-    int                            ret = 0;
-    neu_json_get_file_list_resp_t *resp =
-        (neu_json_get_file_list_resp_t *) param;
-
-    void *                    file_list_array = neu_json_array();
-    neu_json_get_file_resp_t *p_file          = resp->file;
-
-    for (int i = 0; i < resp->n_file; i++) {
-        neu_json_elem_t file_elems[] = {
-            {
-                .name      = "name",
-                .t         = NEU_JSON_STR,
-                .v.val_str = p_file->name,
-            },
-            {
-                .name      = "size",
-                .t         = NEU_JSON_INT,
-                .v.val_int = p_file->size,
-            },
-            {
-                .name      = "ctime",
-                .t         = NEU_JSON_STR,
-                .v.val_str = p_file->ctime,
-            },
-            {
-                .name      = "mtime",
-                .t         = NEU_JSON_STR,
-                .v.val_str = p_file->mtime,
-            },
-        };
-
-        file_list_array = neu_json_encode_array(file_list_array, file_elems,
-                                                NEU_JSON_ELEM_SIZE(file_elems));
-
-        p_file++;
-    }
-
-    neu_json_elem_t resp_elems[] = { {
-        .name         = "files",
-        .t            = NEU_JSON_OBJECT,
-        .v.val_object = file_list_array,
-    } };
-
-    ret = neu_json_encode_field(json_object, resp_elems,
-                                NEU_JSON_ELEM_SIZE(resp_elems));
-
-    return ret;
-}

src/parser/neu_json_file.h

@@ -1,52 +0,0 @@
-/**
- * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- **/
-
-/*
- * DO NOT EDIT THIS FILE MANUALLY!
- * It was automatically generated by `json-autotype`.
- */
-
-#ifndef _NEU_JOSN_API_NEU_JSON_FILE_H_
-#define _NEU_JSON_API_NEU_JSON_FILE_H_
-
-#include "json/json.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-    char *name;
-    int   size;
-    char *ctime;
-    char *mtime;
-} neu_json_get_file_resp_t;
-
-typedef struct {
-    int                       n_file;
-    neu_json_get_file_resp_t *file;
-} neu_json_get_file_list_resp_t;
-
-int neu_json_encode_get_file_list_resp(void *json_object, void *param);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/parser/neu_json_log.c

@@ -42,14 +42,24 @@ int neu_json_decode_update_log_level_req(
         return -1;
     }
 
-    neu_json_elem_t req_elems[] = { {
-                                        .name = "node",
-                                        .t    = NEU_JSON_STR,
-                                    },
-                                    {
-                                        .name = "level",
-                                        .t    = NEU_JSON_STR,
-                                    } };
+    req->node_name = NULL;
+    req->core      = true;
+
+    neu_json_elem_t req_elems[] = {
+        {
+            .name      = "node",
+            .t         = NEU_JSON_STR,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
+        {
+            .name = "level",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name      = "core",
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        }
+    };
 
     ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
                                   req_elems);
@@ -57,8 +67,13 @@ int neu_json_decode_update_log_level_req(
         goto decode_fail;
     }
 
-    req->node_name = req_elems[0].v.val_str;
+    if (req_elems[0].v.val_str != NULL) {
+        req->node_name = req_elems[0].v.val_str;
+    }
     req->log_level = req_elems[1].v.val_str;
+    if (req_elems[2].t == NEU_JSON_BOOL) {
+        req->core = req_elems[2].v.val_bool;
+    }
 
     *result = req;
     goto decode_exit;

src/parser/neu_json_log.h

@@ -36,6 +36,7 @@ typedef char *neu_json_get_log_resp_row_t;
 typedef struct {
     char *node_name;
     char *log_level;
+    bool  core;
 } neu_json_update_log_level_req_t;
 
 typedef struct {

src/parser/neu_json_node.c

@@ -189,6 +189,11 @@ int neu_json_encode_get_node_state_resp(void *json_object, void *param)
                                          .name      = "log_level",
                                          .t         = NEU_JSON_STR,
                                          .v.val_str = resp->log_level,
+                                     },
+                                     {
+                                         .name      = "neuron_core",
+                                         .t         = NEU_JSON_STR,
+                                         .v.val_str = resp->core_level,
                                      } };
     ret = neu_json_encode_field(json_object, resp_elems,
                                 NEU_JSON_ELEM_SIZE(resp_elems));
@@ -236,10 +241,15 @@ int neu_json_encode_get_nodes_state_resp(void *json_object, void *param)
     }
 
     neu_json_elem_t resp_elems[] = { {
-        .name         = "states",
-        .t            = NEU_JSON_OBJECT,
-        .v.val_object = node_array,
-    } };
+                                         .name         = "states",
+                                         .t            = NEU_JSON_OBJECT,
+                                         .v.val_object = node_array,
+                                     },
+                                     {
+                                         .name      = "neuron_core",
+                                         .t         = NEU_JSON_STR,
+                                         .v.val_str = resp->core_level,
+                                     } };
     ret = neu_json_encode_field(json_object, resp_elems,
                                 NEU_JSON_ELEM_SIZE(resp_elems));
 

src/parser/neu_json_node.h

@@ -54,6 +54,7 @@ typedef struct {
     int64_t link;
     int64_t rtt;
     char *  log_level;
+    char *  core_level;
 } neu_json_get_node_state_resp_t;
 
 int neu_json_encode_get_node_state_resp(void *json_object, void *param);
@@ -69,6 +70,7 @@ typedef struct {
 typedef struct {
     uint16_t                    n_node;
     neu_json_get_nodes_state_t *nodes;
+    char *                      core_level;
 } neu_json_get_nodes_state_resp_t;
 
 int neu_json_encode_get_nodes_state_resp(void *json_object, void *param);

src/parser/neu_json_rw.c

@@ -306,14 +306,17 @@ static int decode_write_tags_req_json(void *                     json_obj,
         req->tags[i].value = v_elems[1].v;
 
         if (ret != 0) {
-            while (i-- >= 0) {
+            for (; i >= 0; --i) {
                 free(req->tags[i].tag);
                 if (NEU_JSON_STR == req->tags[i].t) {
                     free(req->tags[i].value.val_str);
                 }
             }
+            free(req->node);
+            free(req->group);
             free(req->tags);
             req->tags = NULL;
+            return ret;
         }
     }
 
@@ -413,14 +416,21 @@ int neu_json_decode_read_req(char *buf, neu_json_read_req_t **result)
 
     json_obj = neu_json_decode_new(buf);
 
-    neu_json_elem_t req_elems[] = { {
-                                        .name = "node",
-                                        .t    = NEU_JSON_STR,
-                                    },
-                                    {
-                                        .name = "group",
-                                        .t    = NEU_JSON_STR,
-                                    } };
+    neu_json_elem_t req_elems[] = {
+        {
+            .name = "node",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name = "group",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name      = "sync",
+            .t         = NEU_JSON_BOOL,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
+    };
     ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
                                   req_elems);
     if (ret != 0) {
@@ -429,6 +439,7 @@ int neu_json_decode_read_req(char *buf, neu_json_read_req_t **result)
 
     req->node  = req_elems[0].v.val_str;
     req->group = req_elems[1].v.val_str;
+    req->sync  = req_elems[2].v.val_bool;
 
     *result = req;
     goto decode_exit;
@@ -548,4 +559,149 @@ void neu_json_metas_to_json(neu_tag_meta_t *metas, int n_meta,
             break;
         }
     }
-}
+}
+
+int neu_json_decode_write_gtags_req(char *                       buf,
+                                    neu_json_write_gtags_req_t **result)
+{
+    void *json_obj = neu_json_decode_new(buf);
+    if (NULL == json_obj) {
+        return -1;
+    }
+
+    int ret = neu_json_decode_write_gtags_req_json(json_obj, result);
+    neu_json_decode_free(json_obj);
+    return ret;
+}
+
+#include "utils/log.h"
+
+static int decode_write_gtags_req_json(void *                      json_obj,
+                                       neu_json_write_gtags_req_t *req)
+{
+    int ret = 0;
+
+    neu_json_elem_t req_elems[] = {
+        {
+            .name = "node",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name = "groups",
+            .t    = NEU_JSON_OBJECT,
+        },
+    };
+    ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
+                                  req_elems);
+    if (ret != 0) {
+        return -1;
+    }
+
+    req->node = req_elems[0].v.val_str;
+
+    req->n_group = neu_json_decode_array_size_by_json(json_obj, "groups");
+    if (req->n_group <= 0) {
+        return -1;
+    }
+
+    req->groups = calloc(req->n_group, sizeof(neu_json_write_gtags_elem_t));
+    for (int i = 0; i < req->n_group; i++) {
+        neu_json_elem_t g_elems[] = {
+            {
+                .name = "group",
+                .t    = NEU_JSON_STR,
+            },
+            {
+                .name = "tags",
+                .t    = NEU_JSON_OBJECT,
+            },
+        };
+
+        ret = neu_json_decode_array_by_json(
+            json_obj, "groups", i, NEU_JSON_ELEM_SIZE(g_elems), g_elems);
+
+        req->groups[i].group = g_elems[0].v.val_str;
+        req->groups[i].n_tag = json_array_size(g_elems[1].v.val_object);
+        if (req->groups[i].n_tag <= 0) {
+            continue;
+        }
+
+        req->groups[i].tags =
+            calloc(req->groups[i].n_tag, sizeof(neu_json_write_tags_elem_t));
+
+        for (int k = 0; k < req->groups[i].n_tag; k++) {
+            neu_json_elem_t v_elems[] = {
+                {
+                    .name = "tag",
+                    .t    = NEU_JSON_STR,
+                },
+                {
+                    .name = "value",
+                    .t    = NEU_JSON_VALUE,
+                },
+            };
+
+            ret = neu_json_decode_array_elem(g_elems[1].v.val_object, k,
+                                             NEU_JSON_ELEM_SIZE(v_elems),
+                                             v_elems);
+            if (ret != 0) {
+                for (int x = i; x >= 0; x--) {
+                    free(req->groups[x].tags);
+                }
+                free(req->groups);
+                return -1;
+            }
+            req->groups[i].tags[k].tag   = v_elems[0].v.val_str;
+            req->groups[i].tags[k].t     = v_elems[1].t;
+            req->groups[i].tags[k].value = v_elems[1].v;
+        }
+    }
+
+    return 0;
+}
+
+int neu_json_decode_write_gtags_req_json(void *                       json_obj,
+                                         neu_json_write_gtags_req_t **result)
+{
+    neu_json_write_gtags_req_t *req =
+        calloc(1, sizeof(neu_json_write_gtags_req_t));
+    if (req == NULL) {
+        return -1;
+    }
+
+    int ret = decode_write_gtags_req_json(json_obj, req);
+    if (0 == ret) {
+        *result = req;
+    } else {
+        free(req);
+    }
+
+    return ret;
+}
+
+void neu_json_decode_write_gtags_req_free(neu_json_write_gtags_req_t *req)
+{
+    free(req->node);
+
+    for (int i = 0; i < req->n_group; i++) {
+        free(req->groups[i].group);
+
+        for (int k = 0; k < req->groups[i].n_tag; k++) {
+            free(req->groups[i].tags[k].tag);
+
+            if (req->groups[i].tags[k].t == NEU_JSON_STR) {
+                free(req->groups[i].tags[k].value.val_str);
+            }
+            if (req->groups[i].tags[k].t == NEU_JSON_BYTES &&
+                req->groups[i].tags[k].value.val_bytes.length > 0) {
+                free(req->groups[i].tags[k].value.val_bytes.bytes);
+            }
+        }
+        if (req->groups[i].n_tag > 0) {
+            free(req->groups[i].tags);
+        }
+    }
+
+    free(req->groups);
+    free(req);
+}

src/utils/http.c

@@ -317,8 +317,6 @@ int neu_http_response(nng_aio *aio, neu_err_code_e code, char *content)
     case NEU_ERR_NEED_TOKEN:
     case NEU_ERR_DECODE_TOKEN:
     case NEU_ERR_INVALID_USER_OR_PASSWORD:
-    case NEU_ERR_INVALID_USER:
-    case NEU_ERR_INVALID_PASSWORD:
         status = NNG_HTTP_STATUS_UNAUTHORIZED;
         break;
     case NEU_ERR_BODY_IS_WRONG:
@@ -352,6 +350,7 @@ int neu_http_response(nng_aio *aio, neu_err_code_e code, char *content)
     case NEU_ERR_NODE_NOT_EXIST:
     case NEU_ERR_TAG_NOT_EXIST:
     case NEU_ERR_LICENSE_NOT_FOUND:
+    case NEU_ERR_LICENSE_TOKEN_NOT_FOUND:
     case NEU_ERR_GROUP_NOT_EXIST:
     case NEU_ERR_GROUP_NOT_SUBSCRIBE:
     case NEU_ERR_COMMAND_EXECUTION_FAILED:

src/utils/json.c

@@ -272,6 +272,25 @@ int neu_json_decode_array(char *buf, char *name, int index, int size,
     return 0;
 }
 
+int neu_json_decode_array_elem(void *json, int index, int size,
+                               neu_json_elem_t *ele)
+{
+    json_t *child = NULL;
+
+    child = json_array_get(json, index);
+    if (child == NULL) {
+        return -1;
+    }
+
+    for (int i = 0; i < size; i++) {
+        if (decode_object(child, &ele[i]) == -1) {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
 int neu_json_decode_array_by_json(void *json, char *name, int index, int size,
                                   neu_json_elem_t *ele)
 {

version

@@ -1 +1 @@
-2.6.1
+2.6.6

zlog.conf

@@ -5,9 +5,9 @@ file perms = 666
 [formats]
 
 simple = "%d:%ms [%V] %f:%L %m%n"
-syslog = "%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
+syslog = "<P>%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
 
 [rules]
 
-*.*     "./logs/%c.log", 50MB * 1 ~ "./logs/%c.#2s.log"; simple
-*.*     $remote_syslog; syslog
+*.*     "./logs/%c.log", 25MB * 1 ~ "./logs/%c.#2r.log"; simple
+*.*     $remote_syslog,"%V"; syslog