From 288175996cc3d89d2aedad85eed471aa3476df43 Mon Sep 17 00:00:00 2001 From: fengzero Date: Wed, 1 Sep 2021 07:35:53 +0000 Subject: [PATCH] Add plugin cmd function add NEU_REQRESP_GET_SELF_NODE_ID cmd add get_datatags_table func define neu_addt_str_t fix compile warning add magic number and check function in neu_plugin_common_t --- CMakeLists.txt | 1 + include/neu_adapter.h | 11 +++ include/neu_plugin.h | 17 +++++ include/neu_types.h | 3 +- plugins/modbus/modbus_tcp.c | 6 +- plugins/mqtt/plugin_mqtt.c | 15 +++-- plugins/restful/handle.c | 1 - plugins/restful/http.c | 1 + plugins/restful/rest.c | 1 + plugins/sample/plugin_sample_app.c | 1 + plugins/sample/plugin_sample_drv.c | 1 + src/adapter/adapter.c | 38 +++++++++++ src/adapter/adapter_info.h | 47 +++++++++++++ src/adapter/adapter_internal.h | 21 +----- src/base/neu_plugin_common.c | 105 +++++++++++++++++++++++++++++ src/core/neu_manager.c | 51 ++++++++------ src/core/neu_manager.h | 5 ++ src/parser/neu_json_read.c | 1 + tests/datatag_table_test.cc | 44 ++++++------ 19 files changed, 296 insertions(+), 74 deletions(-) create mode 100644 src/adapter/adapter_info.h create mode 100644 src/base/neu_plugin_common.c diff --git a/CMakeLists.txt b/CMakeLists.txt index 8da25ad6..35d8186c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -89,6 +89,7 @@ set(NEURON_BASE_SOURCES src/types.c src/base/neu_datatag_table.c src/base/neu_tag_group_config.c + src/base/neu_plugin_common.c src/connection/tcp_client.c src/utils/atomic_data.c src/utils/mem_alloc.c diff --git a/include/neu_adapter.h b/include/neu_adapter.h index 62c3d5a8..fb7f3c2d 100644 --- a/include/neu_adapter.h +++ b/include/neu_adapter.h @@ -60,6 +60,8 @@ typedef enum neu_reqresp_type { NEU_REQRESP_GRP_CONFIGS, NEU_REQRESP_GET_DATATAGS, NEU_REQRESP_DATATAGS, + NEU_REQRESP_SELF_NODE_ID, + NEU_REQRESP_NODE_ID, } neu_reqresp_type_e; typedef uint32_t neu_node_id_t; @@ -175,6 +177,15 @@ typedef struct neu_reqresp_datatags { neu_datatag_table_t *datatag_tbl; // datatag table of a node } neu_reqresp_datatags_t; +/* NEU_REQRESP_SELF_NODE_ID */ +typedef struct neu_cmd_self_node_id { +} neu_cmd_self_node_id_t; + +/* NEU_REQRESP_NODE_ID */ +typedef struct neu_represp_node_id { + neu_node_id_t node_id; +} neu_reqresp_node_id_t; + typedef struct neu_request { uint32_t req_id; neu_reqresp_type_e req_type; diff --git a/include/neu_plugin.h b/include/neu_plugin.h index 3fa945c6..d5183d85 100644 --- a/include/neu_plugin.h +++ b/include/neu_plugin.h @@ -36,9 +36,11 @@ typedef enum neu_plugin_state { } neu_plugin_state_e; typedef struct neu_plugin_common { + uint32_t magic; neu_plugin_state_e state; neu_adapter_t * adapter; const adapter_callbacks_t *adapter_callbacks; + uint32_t event_id; } neu_plugin_common_t; typedef struct neu_plugin neu_plugin_t; @@ -61,6 +63,21 @@ typedef struct neu_plugin_module { const neu_plugin_intf_funs_t *intf_funs; } neu_plugin_module_t; +inline static neu_plugin_common_t * +neu_plugin_to_plugin_common(neu_plugin_t *plugin) +{ + return (neu_plugin_common_t *) plugin; +} + +void neu_plugin_common_init(neu_plugin_common_t *common); +int neu_plugin_common_check(neu_plugin_t *plugin); + +neu_datatag_table_t *neu_plugin_get_datatags_table(neu_plugin_t *plugin, + neu_node_id_t ndoe_id); +intptr_t neu_plugin_add_node(neu_plugin_t *plugin, neu_node_type_e node_type, + const char *adapter_name, const char *plugin_name); +vector_t *neu_plugin_get_nodes(neu_plugin_t *plugin, neu_node_type_e node_type); + #ifdef __cplusplus } #endif diff --git a/include/neu_types.h b/include/neu_types.h index 3ff9f5f8..6ccbf8ab 100644 --- a/include/neu_types.h +++ b/include/neu_types.h @@ -486,6 +486,7 @@ typedef enum { } neu_attributetype_t; typedef uint32_t neu_datatag_id_t; +typedef char * neu_addr_str_t; typedef struct { neu_datatag_id_t id; @@ -494,7 +495,7 @@ typedef struct { // neu_udword_t readInterval; neu_datatype_t dataType; neu_address_t address; - char * str_addr; + neu_addr_str_t addr_str; } neu_datatag_t; /** diff --git a/plugins/modbus/modbus_tcp.c b/plugins/modbus/modbus_tcp.c index 92b808ac..7f8c3b25 100644 --- a/plugins/modbus/modbus_tcp.c +++ b/plugins/modbus/modbus_tcp.c @@ -123,6 +123,8 @@ static neu_plugin_t *modbus_tcp_open(neu_adapter_t * adapter, return NULL; } + neu_plugin_common_init(&plugin->common); + plugin->common.adapter = adapter; plugin->common.adapter_callbacks = callbacks; @@ -235,7 +237,7 @@ static void read_data_process(neu_plugin_t *plugin, neu_request_t *req) int ret = 0; modbus_data_t mdata = { 0 }; - ret = modbus_point_find(plugin->point_ctx, tag->str_addr, &mdata); + ret = modbus_point_find(plugin->point_ctx, tag->addr_str, &mdata); if (ret != 0) { neu_variable_t *err = neu_variable_create(); neu_variable_set_error(err, 1); @@ -399,7 +401,7 @@ static void write_data_process(neu_plugin_t *plugin, neu_request_t *req) break; } } - ret = modbus_point_write(plugin->point_ctx, tag->str_addr, &mdata, + ret = modbus_point_write(plugin->point_ctx, tag->addr_str, &mdata, send_recv_callback); if (ret != 0) { neu_variable_t *err = neu_variable_create(); diff --git a/plugins/mqtt/plugin_mqtt.c b/plugins/mqtt/plugin_mqtt.c index 75bd2d48..f48c3e37 100644 --- a/plugins/mqtt/plugin_mqtt.c +++ b/plugins/mqtt/plugin_mqtt.c @@ -486,10 +486,10 @@ static void plugin_get_tag_list_handle(neu_plugin_t * plugin, continue; } - res.tags[i].name = strdup(ret->str_addr); + res.tags[i].name = strdup(ret->addr_str); res.tags[i].type = 0; res.tags[i].decimal = 1; - res.tags[i].address = strdup(ret->str_addr); + res.tags[i].address = strdup(ret->addr_str); res.tags[i].flag = 0; } @@ -527,7 +527,7 @@ static void plugin_add_tag_handle(neu_plugin_t * plugin, datatag0->type = NEU_ATTRIBUTETYPE_READ; datatag0->dataType = NEU_DATATYPE_BYTE; datatag0->address = datatag_address; - datatag0->str_addr = str_addr; + datatag0->addr_str = str_addr; ids[3] = neu_datatag_tbl_add(data_tag, datatag0); str_addr = (char *) tags[4]; @@ -538,7 +538,7 @@ static void plugin_add_tag_handle(neu_plugin_t * plugin, datatag1->type = NEU_ATTRIBUTETYPE_READ; datatag1->dataType = NEU_DATATYPE_BYTE; datatag1->address = datatag_address; - datatag1->str_addr = str_addr; + datatag1->addr_str = str_addr; ids[4] = neu_datatag_tbl_add(data_tag, datatag1); char * result = NULL; @@ -627,6 +627,7 @@ static neu_plugin_t *mqtt_plugin_open(neu_adapter_t * adapter, return NULL; } + neu_plugin_common_init(&plugin->common); plugin->common.adapter = adapter; plugin->common.adapter_callbacks = callbacks; log_info("Success to create plugin: %s", neu_plugin_module.module_name); @@ -695,7 +696,7 @@ static int mqtt_plugin_config(neu_plugin_t *plugin, neu_config_t *configs) datatag0->type = NEU_ATTRIBUTETYPE_READ; datatag0->dataType = NEU_DATATYPE_WORD; datatag0->address = datatag_address; - datatag0->str_addr = str_addr; + datatag0->addr_str = str_addr; ids[0] = neu_datatag_tbl_add(data_tag, datatag0); str_addr = (char *) tags[1]; @@ -705,7 +706,7 @@ static int mqtt_plugin_config(neu_plugin_t *plugin, neu_config_t *configs) datatag1->type = NEU_ATTRIBUTETYPE_READ; datatag1->dataType = NEU_DATATYPE_UWORD; datatag1->address = datatag_address; - datatag1->str_addr = str_addr; + datatag1->addr_str = str_addr; ids[1] = neu_datatag_tbl_add(data_tag, datatag1); str_addr = (char *) tags[2]; @@ -715,7 +716,7 @@ static int mqtt_plugin_config(neu_plugin_t *plugin, neu_config_t *configs) datatag2->type = NEU_ATTRIBUTETYPE_READ; datatag2->dataType = NEU_DATATYPE_BYTE; datatag2->address = datatag_address; - datatag2->str_addr = str_addr; + datatag2->addr_str = str_addr; ids[2] = neu_datatag_tbl_add(data_tag, datatag2); // str_addr = (char *) tags[3]; diff --git a/plugins/restful/handle.c b/plugins/restful/handle.c index c2268481..86cabd91 100644 --- a/plugins/restful/handle.c +++ b/plugins/restful/handle.c @@ -34,7 +34,6 @@ #include "handle.h" #include "http.h" -static void bad_request(nng_aio *aio, char *error); static void ping(nng_aio *aio); static void read(nng_aio *aio); static void write(nng_aio *aio); diff --git a/plugins/restful/http.c b/plugins/restful/http.c index e3033399..42bd6c5a 100644 --- a/plugins/restful/http.c +++ b/plugins/restful/http.c @@ -46,6 +46,7 @@ static int response(http_response_t *response, enum nng_http_status status) nng_aio_finish(response->aio, 0); nng_http_res_free(res); + return 0; } int http_get_body(nng_aio *aio, void **data, size_t *data_size) diff --git a/plugins/restful/rest.c b/plugins/restful/rest.c index 75e47ad8..c4efbbde 100644 --- a/plugins/restful/rest.c +++ b/plugins/restful/rest.c @@ -128,6 +128,7 @@ static neu_plugin_t *dashb_plugin_open(neu_adapter_t * adapter, return NULL; } + neu_plugin_common_init(&plugin->common); plugin->common.adapter = adapter; plugin->common.adapter_callbacks = callbacks; plugin->new_event_id = 1; diff --git a/plugins/sample/plugin_sample_app.c b/plugins/sample/plugin_sample_app.c index d4970499..ad540eee 100644 --- a/plugins/sample/plugin_sample_app.c +++ b/plugins/sample/plugin_sample_app.c @@ -232,6 +232,7 @@ sample_app_plugin_open(neu_adapter_t * adapter, return NULL; } + neu_plugin_common_init(&plugin->common); plugin->common.adapter = adapter; plugin->common.adapter_callbacks = callbacks; plugin->new_event_id = 1; diff --git a/plugins/sample/plugin_sample_drv.c b/plugins/sample/plugin_sample_drv.c index 06693fab..3111590d 100644 --- a/plugins/sample/plugin_sample_drv.c +++ b/plugins/sample/plugin_sample_drv.c @@ -51,6 +51,7 @@ sample_drv_plugin_open(neu_adapter_t * adapter, return NULL; } + neu_plugin_common_init(&plugin->common); plugin->common.adapter = adapter; plugin->common.adapter_callbacks = callbacks; log_info("Success to create plugin: %s", neu_plugin_module.module_name); diff --git a/src/adapter/adapter.c b/src/adapter/adapter.c index d3647f00..bdd34fa8 100644 --- a/src/adapter/adapter.c +++ b/src/adapter/adapter.c @@ -641,6 +641,38 @@ static int adapter_command(neu_adapter_t *adapter, neu_request_t *cmd, break; } + case NEU_REQRESP_SELF_NODE_ID: { + neu_response_t * result; + neu_reqresp_node_id_t *resp_node_id; + + assert(cmd->buf_len == sizeof(neu_cmd_self_node_id_t)); + resp_node_id = malloc(sizeof(neu_reqresp_node_id_t)); + if (resp_node_id == NULL) { + log_error("Failed to allocate result of node id"); + rv = -1; + break; + } + result = malloc(sizeof(neu_response_t)); + if (result == NULL) { + log_error("Failed to allocate result for get node id"); + free(resp_node_id); + rv = -1; + break; + } + + resp_node_id->node_id = + neu_manager_adapter_id_to_node_id(adapter->manager, adapter->id); + + result->resp_type = NEU_REQRESP_SELF_NODE_ID; + result->req_id = cmd->req_id; + result->buf_len = sizeof(neu_reqresp_node_id_t); + result->buf = resp_node_id; + if (p_result != NULL) { + *p_result = result; + } + break; + } + default: rv = -1; break; @@ -786,6 +818,12 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, if (plugin == NULL) { neu_panic("Can't to open plugin(%s)", plugin_module->module_name); } + + if (neu_plugin_common_check(plugin) != 0) { + neu_panic("Check plugin common magic error, %s", + plugin_module->module_name); + } + adapter->plugin = plugin; rv = nng_pair1_open(&adapter->sock); diff --git a/src/adapter/adapter_info.h b/src/adapter/adapter_info.h new file mode 100644 index 00000000..cbb4f527 --- /dev/null +++ b/src/adapter/adapter_info.h @@ -0,0 +1,47 @@ +/** + * NEURON IIoT System for Industry 4.0 + * Copyright (C) 2020-2021 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 ADAPTER_INFO_H +#define ADAPTER_INFO_H + +#include + +#include "neu_plugin_info.h" + +typedef enum adapter_type { + ADAPTER_TYPE_UNKNOW, + ADAPTER_TYPE_WEBSERVER, + ADAPTER_TYPE_MQTT, + ADAPTER_TYPE_STREAM_PROCESSOR, + ADAPTER_TYPE_APP, + ADAPTER_TYPE_DRIVER, + ADAPTER_TYPE_MAX, +} adapter_type_e; + +typedef uint32_t adapter_id_t; +typedef struct neu_adapter_info { + adapter_id_t id; + adapter_type_e type; + plugin_id_t plugin_id; + const char * name; + plugin_kind_e plugin_kind; + const char * plugin_lib_name; +} neu_adapter_info_t; + +#endif diff --git a/src/adapter/adapter_internal.h b/src/adapter/adapter_internal.h index 7890c84b..b54c7f56 100644 --- a/src/adapter/adapter_internal.h +++ b/src/adapter/adapter_internal.h @@ -22,30 +22,11 @@ #include +#include "adapter_info.h" #include "core/databuf.h" #include "core/neu_manager.h" #include "neu_plugin_info.h" -typedef enum adapter_type { - ADAPTER_TYPE_UNKNOW, - ADAPTER_TYPE_WEBSERVER, - ADAPTER_TYPE_MQTT, - ADAPTER_TYPE_STREAM_PROCESSOR, - ADAPTER_TYPE_APP, - ADAPTER_TYPE_DRIVER, - ADAPTER_TYPE_MAX, -} adapter_type_e; - -typedef uint32_t adapter_id_t; -typedef struct neu_adapter_info { - adapter_id_t id; - adapter_type_e type; - plugin_id_t plugin_id; - const char * name; - plugin_kind_e plugin_kind; - const char * plugin_lib_name; -} neu_adapter_info_t; - neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, neu_manager_t * manager); void neu_adapter_destroy(neu_adapter_t *adapter); diff --git a/src/base/neu_plugin_common.c b/src/base/neu_plugin_common.c new file mode 100644 index 00000000..bf303df1 --- /dev/null +++ b/src/base/neu_plugin_common.c @@ -0,0 +1,105 @@ +/** + * NEURON IIoT System for Industry 4.0 + * Copyright (C) 2020-2021 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 +#include +#include + +#include "neu_plugin.h" + +static uint32_t plugin_get_event_id(neu_plugin_common_t *common); + +#define PLUGIN_CALL_CMD(plugin, type, req_buff, resp_struct, func) \ + { \ + neu_request_t cmd = { 0 }; \ + neu_response_t * result = NULL; \ + neu_plugin_common_t *plugin_common = \ + neu_plugin_to_plugin_common(plugin); \ + cmd.req_type = (type); \ + cmd.req_id = plugin_get_event_id(plugin_common); \ + cmd.buf = (void *) &(req_buff); \ + cmd.buf_len = sizeof(req_buff); \ + if (plugin_common->adapter_callbacks->command( \ + plugin_common->adapter, &(cmd), &(result)) == 0) { \ + assert((result)->buf_len == sizeof(resp_struct)); \ + resp_struct *resp = NULL; \ + resp = (resp_struct *) (result)->buf; \ + { func }; \ + if (strncmp("intptr_t", #resp_struct, strlen("intptr_t")) != 0) { \ + free(resp); \ + } \ + free(result); \ + } \ + } + +static uint32_t plugin_get_event_id(neu_plugin_common_t *common) +{ + common->event_id += 3; + return common->event_id; +} + +void neu_plugin_common_init(neu_plugin_common_t *common) +{ + common->magic = 0xffffffff; +} + +int neu_plugin_common_check(neu_plugin_t *plugin) +{ + return neu_plugin_to_plugin_common(plugin)->magic == 0xffffffff ? 0 : -1; +} + +neu_datatag_table_t *neu_plugin_get_datatags_table(neu_plugin_t *plugin, + neu_node_id_t ndoe_id) +{ + neu_datatag_table_t * tag_table = NULL; + neu_cmd_get_datatags_t get_tags_cmd = { .node_id = ndoe_id }; + + PLUGIN_CALL_CMD(plugin, NEU_REQRESP_GET_DATATAGS, get_tags_cmd, + neu_reqresp_datatags_t, { tag_table = resp->datatag_tbl; }); + return tag_table; +} + +intptr_t neu_plugin_add_node(neu_plugin_t *plugin, neu_node_type_e node_type, + const char *adapter_name, const char *plugin_name) +{ + intptr_t errorcode = -1; + neu_cmd_add_node_t node_add_cmd = { 0 }; + + node_add_cmd.node_type = node_type; + node_add_cmd.adapter_name = adapter_name; + node_add_cmd.plugin_name = plugin_name; + + PLUGIN_CALL_CMD(plugin, NEU_REQRESP_ADD_NODE, node_add_cmd, intptr_t, + { errorcode = (intptr_t) resp; }) + + return errorcode; +} + +vector_t *neu_plugin_get_nodes(neu_plugin_t *plugin, neu_node_type_e node_type) +{ + vector_t * nodes = NULL; + neu_cmd_get_nodes_t get_nodes_cmd = { 0 }; + + get_nodes_cmd.node_type = NEU_NODE_TYPE_DRIVER; + + PLUGIN_CALL_CMD(plugin, NEU_REQRESP_GET_NODES, get_nodes_cmd, + neu_reqresp_nodes_t, { nodes = &resp->nodes; }) + + return nodes; +} \ No newline at end of file diff --git a/src/core/neu_manager.c b/src/core/neu_manager.c index 94b4f166..cb2a31a1 100644 --- a/src/core/neu_manager.c +++ b/src/core/neu_manager.c @@ -375,16 +375,18 @@ static adapter_id_t manager_get_adapter_id(neu_manager_t *manager) nng_mtx_unlock(manager->adapters_mtx); return adapter_id; } - -static adapter_id_t adapter_id_from_node_id(neu_node_id_t node_id) -{ - return node_id; -} - -static neu_node_id_t adapter_id_to_node_id(adapter_id_t adapter_id) +neu_node_id_t neu_manager_adapter_id_to_node_id(neu_manager_t *manager, + adapter_id_t adapter_id) { + (void) manager; return adapter_id; } +adapter_id_t neu_manager_adapter_id_from_node_id(neu_manager_t *manager, + neu_node_id_t node_id) +{ + (void) manager; + return node_id; +} static void manager_bind_adapter(nng_pipe p, nng_pipe_ev ev, void *arg) { @@ -907,7 +909,8 @@ static void manager_loop(void *arg) cmd_ptr = (read_data_cmd_t *) msg_get_buf_ptr(pay_msg); nng_mtx_lock(manager->adapters_mtx); - adapter_id = adapter_id_from_node_id(cmd_ptr->dst_node_id); + adapter_id = neu_manager_adapter_id_from_node_id( + manager, cmd_ptr->dst_node_id); reg_entity = find_reg_adapter_by_id(&manager->reg_adapters, adapter_id); msg_pipe = reg_entity->adapter_pipe; @@ -939,7 +942,8 @@ static void manager_loop(void *arg) cmd_ptr = (write_data_cmd_t *) msg_get_buf_ptr(pay_msg); nng_mtx_lock(manager->adapters_mtx); - adapter_id = adapter_id_from_node_id(cmd_ptr->dst_node_id); + adapter_id = neu_manager_adapter_id_from_node_id( + manager, cmd_ptr->dst_node_id); reg_entity = find_reg_adapter_by_id(&manager->reg_adapters, adapter_id); msg_pipe = reg_entity->adapter_pipe; @@ -1121,7 +1125,7 @@ neu_node_id_t neu_manager_add_node(neu_manager_t * manager, reg_cmd.plugin_name = cmd->plugin_name; reg_cmd.plugin_id = cmd->plugin_id; adapter_id = manager_reg_adapter(manager, ®_cmd, NULL); - return adapter_id_to_node_id(adapter_id); + return neu_manager_adapter_id_to_node_id(manager, adapter_id); } int neu_manager_del_node(neu_manager_t *manager, neu_node_id_t node_id) @@ -1129,7 +1133,7 @@ int neu_manager_del_node(neu_manager_t *manager, neu_node_id_t node_id) int rv = 0; adapter_id_t adapter_id; - adapter_id = adapter_id_from_node_id(node_id); + adapter_id = neu_manager_adapter_id_from_node_id(manager, node_id); rv = manager_unreg_adapter(manager, adapter_id); return rv; } @@ -1175,9 +1179,10 @@ int neu_manager_get_nodes(neu_manager_t *manager, neu_node_type_e node_type, adapter_id_t adapter_id; const char * adapter_name; - adapter_name = neu_adapter_get_name(reg_entity->adapter); - adapter_id = neu_adapter_get_id(reg_entity->adapter); - node_info.node_id = adapter_id_to_node_id(adapter_id); + adapter_name = neu_adapter_get_name(reg_entity->adapter); + adapter_id = neu_adapter_get_id(reg_entity->adapter); + node_info.node_id = + neu_manager_adapter_id_to_node_id(manager, adapter_id); node_info.node_name = strdup(adapter_name); vector_push_back(result_nodes, &node_info); } @@ -1207,8 +1212,10 @@ int neu_manager_add_grp_config(neu_manager_t * manager, } nng_mtx_lock(manager->adapters_mtx); - src_adapter_id = adapter_id_from_node_id(cmd->src_node_id); - dst_adapter_id = adapter_id_from_node_id(cmd->dst_node_id); + src_adapter_id = + neu_manager_adapter_id_from_node_id(manager, cmd->src_node_id); + dst_adapter_id = + neu_manager_adapter_id_from_node_id(manager, cmd->dst_node_id); src_reg_entity = find_reg_adapter_by_id(&manager->reg_adapters, src_adapter_id); dst_reg_entity = @@ -1239,7 +1246,7 @@ int neu_manager_del_grp_config(neu_manager_t *manager, neu_node_id_t node_id, } nng_mtx_lock(manager->adapters_mtx); - adapter_id = adapter_id_from_node_id(node_id); + adapter_id = neu_manager_adapter_id_from_node_id(manager, node_id); reg_entity = find_reg_adapter_by_id(&manager->reg_adapters, adapter_id); if (reg_entity == NULL) { log_error("Can't find matched registered adapter"); @@ -1277,8 +1284,10 @@ int neu_manager_update_grp_config(neu_manager_t * manager, } nng_mtx_lock(manager->adapters_mtx); - src_adapter_id = adapter_id_from_node_id(cmd->src_node_id); - dst_adapter_id = adapter_id_from_node_id(cmd->dst_node_id); + src_adapter_id = + neu_manager_adapter_id_from_node_id(manager, cmd->src_node_id); + dst_adapter_id = + neu_manager_adapter_id_from_node_id(manager, cmd->dst_node_id); src_reg_entity = find_reg_adapter_by_id(&manager->reg_adapters, src_adapter_id); dst_reg_entity = @@ -1325,7 +1334,7 @@ int neu_manager_get_grp_configs(neu_manager_t *manager, neu_node_id_t node_id, } nng_mtx_lock(manager->adapters_mtx); - adapter_id = adapter_id_from_node_id(node_id); + adapter_id = neu_manager_adapter_id_from_node_id(manager, node_id); VECTOR_FOR_EACH(&manager->reg_adapters, iter) { reg_entity = (adapter_reg_entity_t *) iterator_get(&iter); @@ -1353,7 +1362,7 @@ neu_datatag_table_t *neu_manager_get_datatag_tbl(neu_manager_t *manager, tag_table = NULL; nng_mtx_lock(manager->adapters_mtx); - adapter_id = adapter_id_from_node_id(node_id); + adapter_id = neu_manager_adapter_id_from_node_id(manager, node_id); VECTOR_FOR_EACH(&manager->reg_adapters, iter) { reg_entity = (adapter_reg_entity_t *) iterator_get(&iter); diff --git a/src/core/neu_manager.h b/src/core/neu_manager.h index a80f58fe..0c11a62c 100644 --- a/src/core/neu_manager.h +++ b/src/core/neu_manager.h @@ -20,6 +20,7 @@ #ifndef NEURON_MANAGER_H #define NEURON_MANAGER_H +#include "adapter/adapter_info.h" #include "neu_adapter.h" #define DEFAULT_ADAPTER_REG_COUNT 8 @@ -49,4 +50,8 @@ int neu_manager_get_grp_configs(neu_manager_t *manager, neu_node_id_t node_id, neu_datatag_table_t *neu_manager_get_datatag_tbl(neu_manager_t *manager, neu_node_id_t node_id); +neu_node_id_t neu_manager_adapter_id_to_node_id(neu_manager_t *manager, + adapter_id_t adapter_id); +adapter_id_t neu_manager_adapter_id_from_node_id(neu_manager_t *manager, + neu_node_id_t node_id); #endif diff --git a/src/parser/neu_json_read.c b/src/parser/neu_json_read.c index 70fb8b08..aa87926c 100644 --- a/src/parser/neu_json_read.c +++ b/src/parser/neu_json_read.c @@ -18,6 +18,7 @@ **/ #include +#include #include "utils/json.h" diff --git a/tests/datatag_table_test.cc b/tests/datatag_table_test.cc index 68d9030c..153c17b1 100644 --- a/tests/datatag_table_test.cc +++ b/tests/datatag_table_test.cc @@ -10,13 +10,13 @@ TEST(DatatageTableTest, DatatagTableAdd) neu_datatag_table_t *datatag_table_create = neu_datatag_tbl_create(); neu_datatag_id_t id; neu_address_t datatag_address; - char * str_addr; + char * addr_str; neu_datatag_t datatag1 = { id, NEU_ATTRIBUTETYPE_READ, NEU_DATATYPE_BYTE, - datatag_address, str_addr }; + datatag_address, addr_str }; neu_datatag_t datatag2 = { id, NEU_ATTRIBUTETYPE_WRITE, NEU_DATATYPE_WORD, - datatag_address, str_addr }; + datatag_address, addr_str }; neu_datatag_t datatag3 = { id, NEU_ATTRIBUTETYPE_SUBSCRIBE, - NEU_DATATYPE_UWORD, datatag_address, str_addr }; + NEU_DATATYPE_UWORD, datatag_address, addr_str }; datatag_id_t datatag_id1, datatag_id2, datatag_id3; neu_datatag_t *datatag_id_return1 = NULL; @@ -34,17 +34,17 @@ TEST(DatatageTableTest, DatatagTableAdd) EXPECT_EQ(datatag_id_return1->id, datatag1.id); EXPECT_EQ(datatag_id_return1->dataType, datatag1.dataType); EXPECT_EQ(datatag_id_return1->type, datatag1.type); - EXPECT_EQ(datatag_id_return1->str_addr, datatag1.str_addr); + EXPECT_EQ(datatag_id_return1->addr_str, datatag1.addr_str); EXPECT_EQ(datatag_id_return2->id, datatag2.id); EXPECT_EQ(datatag_id_return2->dataType, datatag2.dataType); EXPECT_EQ(datatag_id_return2->type, datatag2.type); - EXPECT_EQ(datatag_id_return2->str_addr, datatag2.str_addr); + EXPECT_EQ(datatag_id_return2->addr_str, datatag2.addr_str); EXPECT_EQ(datatag_id_return3->id, datatag3.id); EXPECT_EQ(datatag_id_return3->dataType, datatag3.dataType); EXPECT_EQ(datatag_id_return3->type, datatag3.type); - EXPECT_EQ(datatag_id_return3->str_addr, datatag3.str_addr); + EXPECT_EQ(datatag_id_return3->addr_str, datatag3.addr_str); neu_datatag_tbl_destroy(datatag_table_create); } @@ -54,13 +54,13 @@ TEST(DatatageTableTest, DatatagTableRemove) neu_datatag_table_t *datatag_table_create = neu_datatag_tbl_create(); neu_address_t datatag_address; neu_datatag_id_t id; - char * str_addr; + char * addr_str; neu_datatag_t datatag1 = { id, NEU_ATTRIBUTETYPE_READ, NEU_DATATYPE_BYTE, - datatag_address, str_addr }; + datatag_address, addr_str }; neu_datatag_t datatag2 = { id, NEU_ATTRIBUTETYPE_WRITE, NEU_DATATYPE_WORD, - datatag_address, str_addr }; + datatag_address, addr_str }; neu_datatag_t datatag3 = { id, NEU_ATTRIBUTETYPE_SUBSCRIBE, - NEU_DATATYPE_UWORD, datatag_address, str_addr }; + NEU_DATATYPE_UWORD, datatag_address, addr_str }; datatag_id_t datatag_id1, datatag_id2, datatag_id3; neu_datatag_t *datatag_id_return1 = NULL; @@ -82,12 +82,12 @@ TEST(DatatageTableTest, DatatagTableRemove) EXPECT_EQ(datatag_id_return2->id, datatag2.id); EXPECT_EQ(datatag_id_return2->dataType, datatag2.dataType); EXPECT_EQ(datatag_id_return2->type, datatag2.type); - EXPECT_EQ(datatag_id_return2->str_addr, datatag2.str_addr); + EXPECT_EQ(datatag_id_return2->addr_str, datatag2.addr_str); EXPECT_EQ(datatag_id_return3->id, datatag3.id); EXPECT_EQ(datatag_id_return3->dataType, datatag3.dataType); EXPECT_EQ(datatag_id_return3->type, datatag3.type); - EXPECT_EQ(datatag_id_return3->str_addr, datatag3.str_addr); + EXPECT_EQ(datatag_id_return3->addr_str, datatag3.addr_str); neu_datatag_tbl_destroy(datatag_table_create); } @@ -97,9 +97,9 @@ TEST(DatatageTableTest, DatatagTableUpdate) neu_datatag_table_t *datatag_table_create = neu_datatag_tbl_create(); neu_address_t datatag_address; neu_datatag_id_t id; - char * str_addr; + char * addr_str; neu_datatag_t datatag = { id, NEU_ATTRIBUTETYPE_READ, NEU_DATATYPE_BYTE, - datatag_address, str_addr }; + datatag_address, addr_str }; datatag_id_t datatag_id; neu_datatag_t *datatag_id_return = NULL; @@ -116,7 +116,7 @@ TEST(DatatageTableTest, DatatagTableUpdate) EXPECT_EQ(datatag_id_return->type, NEU_ATTRIBUTETYPE_WRITE); EXPECT_EQ(datatag_id_return->dataType, NEU_DATATYPE_BOOLEAN); EXPECT_EQ(datatag_id_return->id, datatag.id); - EXPECT_EQ(datatag_id_return->str_addr, datatag.str_addr); + EXPECT_EQ(datatag_id_return->addr_str, datatag.addr_str); neu_datatag_tbl_destroy(datatag_table_create); } @@ -126,13 +126,13 @@ void *datatag_table_thread(void *arg) neu_datatag_table_t *datatag_table_create = (neu_datatag_table_t *) arg; neu_address_t address; datatag_id_t id; - char * str_addr; + char * addr_str; neu_datatag_t datatag1 = { id, NEU_ATTRIBUTETYPE_READ, NEU_DATATYPE_BYTE, - address, str_addr }; + address, addr_str }; neu_datatag_t datatag2 = { id, NEU_ATTRIBUTETYPE_WRITE, NEU_DATATYPE_WORD, - address, str_addr }; + address, addr_str }; neu_datatag_t datatag3 = { id, NEU_ATTRIBUTETYPE_SUBSCRIBE, - NEU_DATATYPE_UWORD, address, str_addr }; + NEU_DATATYPE_UWORD, address, addr_str }; datatag_id_t datatag_id1, datatag_id2, datatag_id3; neu_datatag_t *datatag_id_return1 = NULL; @@ -167,12 +167,12 @@ void *datatag_table_thread(void *arg) EXPECT_EQ(datatag_id_return2->id, datatag2.id); EXPECT_EQ(datatag_id_return2->type, NEU_ATTRIBUTETYPE_WRITE); EXPECT_EQ(datatag_id_return2->dataType, datatag2.dataType); - EXPECT_EQ(datatag_id_return2->str_addr, datatag2.str_addr); + EXPECT_EQ(datatag_id_return2->addr_str, datatag2.addr_str); EXPECT_EQ(datatag_id_return3->id, datatag3.id); EXPECT_EQ(datatag_id_return3->dataType, NEU_DATATYPE_BOOLEAN); EXPECT_EQ(datatag_id_return3->type, datatag3.type); - EXPECT_EQ(datatag_id_return3->str_addr, datatag3.str_addr); + EXPECT_EQ(datatag_id_return3->addr_str, datatag3.addr_str); } return 0; }