GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-18 21:50:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

remove libcsptr

Browse Source
This commit is contained in:
fengzero
2022-06-03 10:56:57 +00:00
parent 7d6e7c7a37
commit 574fab1057
10 changed files with 2 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitmodules
-3
View File
@@ -1,9 +1,6 @@
[submodule "extern/vector"]
path = extern/vector
url = https://github.com/flyfish30/vector.git
[submodule "extern/libcsptr"]
path = extern/libcsptr
url = https://github.com/neugates/libcsptr.git
[submodule "extern/uthash"]
path = extern/uthash
url = https://github.com/troydhanson/uthash.git
CMakeLists.txt
+1 -13
View File
@@ -48,18 +48,6 @@ configure_file(extern/uthash/include/utlist.h ${CMAKE_SOURCE_DIR}/include/neuron
add_subdirectory(extern/vector)
set_property(TARGET vector-static PROPERTY POSITION_INDEPENDENT_CODE ON)
add_subdirectory(extern/libcsptr)
configure_file(extern/vector/vector.h ${CMAKE_SOURCE_DIR}/include/neuron/vector.h
COPYONLY)
configure_file(extern/libcsptr/include/csptr/smart_ptr.h ${CMAKE_SOURCE_DIR}/include/csptr/smart_ptr.h
COPYONLY)
configure_file(extern/libcsptr/include/csptr/common.h ${CMAKE_SOURCE_DIR}/include/csptr/common.h
COPYONLY)
configure_file(extern/libcsptr/include/csptr/smalloc.h ${CMAKE_SOURCE_DIR}/include/csptr/smalloc.h
COPYONLY)
configure_file(extern/libcsptr/include/csptr/config.h ${CMAKE_SOURCE_DIR}/include/csptr/config.h
COPYONLY)
# Call this from your own project's makefile.
if(NOT CMAKE_STAGING_PREFIX)
@@ -111,7 +99,7 @@ set(NEURON_SOURCES
src/daemon.c
src/core/message.c
src/core/databuf.c
src/core/neu_trans_buf.c
# src/core/neu_trans_buf.c
# src/core/neu_manager.c
#src/core/plugin_manager.c
#src/core/neu_datatag_manager.c
extern/libcsptr
Vendored
-1
Submodule extern/libcsptr deleted from d45a9f6b45
src/adapter/adapter.c
+1 -2
View File
@@ -32,7 +32,7 @@
#include "adapter.h"
#include "adapter_internal.h"
#include "core/message.h"
#include "core/neu_trans_buf.h"
//#include "core/neu_trans_buf.h"
#include "driver/driver_internal.h"
#include "persist/persist.h"
#include "plugin.h"
@@ -1119,7 +1119,6 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info,
adapter->manager = manager;
adapter->plugin_info.handle = info->handle;
adapter->plugin_info.module = info->module;
adapter->trans_kind = NEURON_TRANS_DATAVAL;
adapter->req_id = 1;
rv = nng_mtx_alloc(&adapter->nng.mtx);
src/adapter/adapter_internal.h
-2
View File
@@ -32,7 +32,6 @@
#include "core/databuf.h"
//#include "core/neu_manager.h"
#include "core/manager.h"
#include "core/neu_trans_buf.h"
#include "plugin_info.h"
typedef enum adapter_state {
@@ -51,7 +50,6 @@ struct neu_adapter {
uint32_t req_id;
neu_trans_kind_e trans_kind;
adapter_callbacks_t cb_funs;
neu_config_t setting;
void * x;
src/core/message.h
-1
View File
@@ -23,7 +23,6 @@
#include <assert.h>
#include "databuf.h"
#include "neu_trans_buf.h"
#include "adapter/adapter_internal.h"
src/core/neu_trans_buf.c
-207
View File
@@ -1,207 +0,0 @@
/**
* 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 <inttypes.h>
#include <stdint.h>
#include <stdlib.h>
#include "csptr/smart_ptr.h"
#include "utils/log.h"
#include "core/databuf.h"
#include "core/message.h"
#include "core/neu_trans_buf.h"
neu_trans_buf_t *neu_trans_buf_new(neu_trans_kind_e trans_kind,
neu_data_val_t * data_val)
{
int rv;
neu_trans_buf_t *trans_buf;
trans_buf = (neu_trans_buf_t *) malloc(sizeof(neu_trans_buf_t));
if (trans_buf == NULL) {
zlog_error(neuron, "Failed to allocate trans data");
neu_dvalue_free(data_val);
return NULL;
}
rv = neu_trans_buf_init(trans_buf, trans_kind, data_val);
if (rv != 0) {
return NULL;
}
return trans_buf;
}
void neu_trans_buf_free(neu_trans_buf_t *trans_buf)
{
if (trans_buf == NULL) {
zlog_error(neuron, "Free neuron trans_buf with NULL pointer");
return;
}
neu_trans_buf_uninit(trans_buf);
free(trans_buf);
}
static void dvalue_dtor(void *p_data_val, void *meta)
{
(void) meta;
neu_dvalue_free(*(neu_data_val_t **) p_data_val);
return;
}
int neu_trans_buf_init(neu_trans_buf_t *trans_buf, neu_trans_kind_e trans_kind,
neu_data_val_t *data_val)
{
int rv = 0;
size_t buf_len;
uint8_t * buf;
core_databuf_t *databuf;
neu_data_val_t *owned_data_val;
if (trans_buf == NULL || data_val == NULL) {
zlog_error(neuron, "Init neuron trans_buf with NULL pointer");
neu_dvalue_free(data_val);
return -1;
}
trans_buf->trans_kind = trans_kind;
switch (trans_kind) {
case NEURON_TRANS_DATABUF:
buf_len = neu_dvalue_serialize(data_val, &buf);
databuf = core_databuf_new_with_buf(buf, buf_len);
neu_dvalue_free(data_val);
if (databuf == NULL) {
zlog_error(
neuron,
"Failed to serialize data value(%p) or new buf with len(%zu)",
data_val, buf_len);
rv = -1;
break;
}
trans_buf->databuf = databuf;
break;
case NEURON_TRANS_DATAVAL:
owned_data_val = neu_dvalue_to_owned(data_val);
if (owned_data_val == NULL) {
neu_dvalue_free(data_val);
zlog_error(neuron, "Failed to owner the data value(%p)", data_val);
rv = -1;
break;
}
trans_buf->shared_dataval =
shared_ptr(void *, owned_data_val, dvalue_dtor);
break;
default:
neu_dvalue_free(data_val);
zlog_error(neuron, "Not support trans data kind: %d", trans_kind);
rv = -1;
break;
}
return rv;
}
void neu_trans_buf_uninit(neu_trans_buf_t *trans_buf)
{
neu_trans_kind_e trans_kind;
if (trans_buf == NULL) {
zlog_error(neuron, "Uninit neuron trans_buf with NULL pointer");
return;
}
trans_kind = trans_buf->trans_kind;
switch (trans_kind) {
case NEURON_TRANS_DATABUF:
core_databuf_put(trans_buf->databuf);
break;
case NEURON_TRANS_DATAVAL:
sfree(trans_buf->shared_dataval);
break;
default:
zlog_error(neuron, "Not support trans data kind: %d", trans_kind);
break;
}
return;
}
neu_data_val_t *neu_trans_buf_get_data_val(neu_trans_buf_t *trans_buf,
bool * is_need_free)
{
neu_trans_kind_e trans_kind;
neu_data_val_t * data_val = NULL;
if (trans_buf == NULL || is_need_free == NULL) {
zlog_error(neuron, "Get data value from trans_buf with NULL pointer");
return NULL;
}
*is_need_free = false;
trans_kind = trans_buf->trans_kind;
switch (trans_kind) {
case NEURON_TRANS_DATABUF: {
void * buf = core_databuf_get_ptr(trans_buf->databuf);
size_t buf_len = core_databuf_get_len(trans_buf->databuf);
neu_dvalue_deserialize(buf, buf_len, &data_val);
*is_need_free = true;
break;
}
case NEURON_TRANS_DATAVAL:
data_val = *(neu_data_val_t **) (trans_buf->shared_dataval);
*is_need_free = false;
break;
default:
zlog_error(neuron, "Not support trans data kind: %d", trans_kind);
break;
}
return data_val;
}
void neu_trans_buf_copy(neu_trans_buf_t *dst, neu_trans_buf_t *src)
{
neu_trans_kind_e trans_kind;
if (dst == NULL || src == NULL) {
zlog_error(neuron, "Copy trans data with NULL pointer");
return;
}
dst->trans_kind = src->trans_kind;
trans_kind = src->trans_kind;
switch (trans_kind) {
case NEURON_TRANS_DATABUF:
dst->databuf = core_databuf_get(src->databuf);
break;
case NEURON_TRANS_DATAVAL:
dst->shared_dataval = sref(src->shared_dataval);
break;
default:
zlog_error(neuron, "Not support trans data kind: %d", trans_kind);
break;
}
return;
}
src/core/neu_trans_buf.h
-62
View File
@@ -1,62 +0,0 @@
/**
* 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 NEURON_TRANS_BUF_H
#define NEURON_TRANS_BUF_H
#include "data_expr.h"
#include "databuf.h"
typedef enum neu_trans_kind {
NEURON_TRANS_DATABUF,
NEURON_TRANS_DATAVAL,
} neu_trans_kind_e;
/*
* A databuf or shared data value for transfer data to other adapter
*/
typedef struct neu_trans_buf {
neu_trans_kind_e trans_kind;
union {
core_databuf_t *databuf;
void * shared_dataval;
};
} neu_trans_buf_t;
/**
* New a transfer buf with data value, the ownership of data value will be
* move to this function, and free data value in this function.
*/
neu_trans_buf_t *neu_trans_buf_new(neu_trans_kind_e trans_kind,
neu_data_val_t * data_val);
void neu_trans_buf_free(neu_trans_buf_t *trans_buf);
/**
* Initialize a transfer buf with data value, the ownership of data value will
* be move to this function, and free data value in this function.
*/
int neu_trans_buf_init(neu_trans_buf_t *trans_buf, neu_trans_kind_e trans_kind,
neu_data_val_t *data_val);
void neu_trans_buf_uninit(neu_trans_buf_t *trans_buf);
neu_data_val_t *neu_trans_buf_get_data_val(neu_trans_buf_t *trans_buf,
bool * is_need_free);
void neu_trans_buf_copy(neu_trans_buf_t *dst, neu_trans_buf_t *src);
#endif
tests/CMakeLists.txt
-9
View File
@@ -84,14 +84,6 @@ target_include_directories(json_persistence_test PRIVATE
)
target_link_libraries(json_persistence_test neuron-base gtest_main gtest)
aux_source_directory(${CMAKE_SOURCE_DIR}/src/persist SRC_PERSIST)
add_executable(persistence_test persistence_test.cc ${SRC_PERSIST_JSON} ${SRC_PERSIST})
target_include_directories(persistence_test PRIVATE
${CMAKE_SOURCE_DIR}/src
${CMAKE_SOURCE_DIR}/include
)
target_link_libraries(persistence_test neuron-base gtest_main gtest)
file(COPY ${CMAKE_SOURCE_DIR}/neuron.key DESTINATION ${CMAKE_BINARY_DIR}/tests/config)
file(COPY ${CMAKE_SOURCE_DIR}/neuron.pem DESTINATION ${CMAKE_BINARY_DIR}/tests/config)
add_executable(jwt_test jwt_test.cc)
@@ -129,6 +121,5 @@ gtest_discover_tests(http_test)
gtest_discover_tests(mqtt_test)
gtest_discover_tests(jwt_test)
gtest_discover_tests(json_persistence_test)
gtest_discover_tests(persistence_test)
gtest_discover_tests(base64_test)
gtest_discover_tests(tag_sort_test)
tests/persistence_test.cc
-292
View File
@@ -1,292 +0,0 @@
#include <gtest/gtest.h>
#include "persist/persist.h"
#include "utils/log.h"
zlog_category_t *neuron = NULL;
TEST(PersistenceAdapterTest, Adapter)
{
const char * dir_name = strdup("./persistence");
neu_persister_t *persister = neu_persister_create(dir_name);
const char * persist_dir = neu_persister_get_persist_dir(persister);
const char *adapters_fname = neu_persister_get_adapters_fname(persister);
const char *plugins_fname = neu_persister_get_plugins_fname(persister);
neu_json_node_req_node_t node1 = { 1, (char *) "sample-driver-adapter", 1,
(char *) "sample-drv-plugin", 1 };
neu_json_node_req_node_t node2 = { 2, (char *) "sample-app-adapter", 5,
(char *) "sample-app-plugin", 2 };
neu_json_node_req_node_t node3 = { 3, (char *) "mqtt-adapter", 3,
(char *) "mqtt-plugin", 3 };
EXPECT_EQ(0, neu_persister_store_adapter(persister, &node1));
EXPECT_EQ(0, neu_persister_store_adapter(persister, &node2));
EXPECT_EQ(0, neu_persister_store_adapter(persister, &node3));
vector_t *nodes = NULL;
EXPECT_EQ(0, neu_persister_load_adapters(persister, &nodes));
VECTOR_FOR_EACH(nodes, iter)
{
neu_json_node_req_node_t *info =
(neu_json_node_req_node_t *) iterator_get(&iter);
if (strcmp(info->name, "sample-driver-adapter") == 0) {
EXPECT_EQ(1, info->type);
EXPECT_STREQ("sample-drv-plugin", info->plugin_name);
EXPECT_EQ(1, info->state);
} else if (strcmp(info->name, "sample-app-adapter") == 0) {
EXPECT_EQ(5, info->type);
EXPECT_STREQ("sample-app-plugin", info->plugin_name);
EXPECT_EQ(2, info->state);
} else if (strcmp(info->name, "mqtt-adapter") == 0) {
EXPECT_EQ(3, info->type);
EXPECT_STREQ("mqtt-plugin", info->plugin_name);
EXPECT_EQ(3, info->state);
} else {
EXPECT_EQ(1, 2);
}
free(info->name);
free(info->plugin_name);
}
vector_free(nodes);
free((char *) dir_name);
free((char *) persist_dir);
free((char *) adapters_fname);
free((char *) plugins_fname);
free(persister);
}
TEST(PersistencePluginTest, Plugin)
{
const char * dir_name = strdup("./persistence");
neu_persister_t *persister = neu_persister_create(dir_name);
const char * persist_dir = neu_persister_get_persist_dir(persister);
const char *adapters_fname = neu_persister_get_adapters_fname(persister);
const char *plugins_fname = neu_persister_get_plugins_fname(persister);
neu_json_plugin_req_plugin_t plugin1 = { (
char *) "libplugin-sample-drv.so" };
neu_json_plugin_req_plugin_t plugin2 = { (
char *) "libplugin-sample-app.so" };
neu_json_plugin_req_plugin_t plugin3 = { (char *) "libplugin-mqtt.so" };
neu_json_plugin_req_t *req =
(neu_json_plugin_req_t *) malloc(sizeof(neu_json_plugin_req_t));
req->plugins = (neu_json_plugin_req_plugin_t *) calloc(
3, sizeof(neu_json_plugin_req_plugin_t));
req->n_plugin = 3;
req->plugins[0] = plugin1;
req->plugins[1] = plugin2;
req->plugins[2] = plugin3;
vector_t *vec =
vector_new_move_from_buf(req->plugins, req->n_plugin, req->n_plugin,
sizeof(neu_json_plugin_req_plugin_t));
EXPECT_EQ(0, neu_persister_store_plugins(persister, vec));
vector_t *plugins = NULL;
EXPECT_EQ(0, neu_persister_load_plugins(persister, &plugins));
VECTOR_FOR_EACH(plugins, iter)
{
neu_json_plugin_req_plugin_t *info =
(neu_json_plugin_req_plugin_t *) iterator_get(&iter);
if (strcmp(*info, "libplugin-sample-drv.so") == 0) {
EXPECT_STREQ("libplugin-sample-drv.so", *info);
} else if (strcmp(*info, "libplugin-sample-app.so") == 0) {
EXPECT_STREQ("libplugin-sample-app.so", *info);
} else if (strcmp(*info, "libplugin-mqtt.so") == 0) {
EXPECT_STREQ("libplugin-mqtt.so", *info);
} else {
EXPECT_EQ(1, 2);
}
free(*info);
}
vector_free(plugins);
vector_free(vec);
free(req);
free((char *) persist_dir);
free((char *) adapters_fname);
free((char *) plugins_fname);
free(persister);
free((char *) dir_name);
}
TEST(PersistenceDatatagTest, Datatag)
{
const char * dir_name = strdup("./persistence");
neu_persister_t *persister = neu_persister_create(dir_name);
const char * persist_dir = neu_persister_get_persist_dir(persister);
const char *adapters_fname = neu_persister_get_adapters_fname(persister);
const char *grp_config_name = "test-group";
const char *plugins_fname = neu_persister_get_plugins_fname(persister);
neu_json_datatag_req_tag_t tag1 = { 1, (char *) "1!400001",
(char *) "modbus1", 3, 1 };
neu_json_datatag_req_tag_t tag2 = { 2, (char *) "1!400002",
(char *) "modbus2", 4, 1 };
neu_json_datatag_req_tag_t tag3 = { 3, (char *) "1!400003",
(char *) "modbus3", 5, 1 };
neu_json_datatag_req_t *req =
(neu_json_datatag_req_t *) malloc(sizeof(neu_json_datatag_req_t));
req->tags = (neu_json_datatag_req_tag_t *) calloc(
3, sizeof(neu_json_datatag_req_tag_t));
req->n_tag = 3;
req->tags[0] = tag1;
req->tags[1] = tag2;
req->tags[2] = tag3;
vector_t *vec = vector_new_move_from_buf(
req->tags, req->n_tag, req->n_tag, sizeof(neu_json_datatag_req_tag_t));
char *adapter_name = strdup("adapter_modbus");
EXPECT_EQ(0,
neu_persister_store_datatags(persister, adapter_name,
grp_config_name, vec));
vector_t *tags = NULL;
EXPECT_EQ(0,
neu_persister_load_datatags(persister, adapter_name,
grp_config_name, &tags));
VECTOR_FOR_EACH(tags, iter)
{
neu_json_datatag_req_tag_t *info =
(neu_json_datatag_req_tag_t *) iterator_get(&iter);
if (strcmp(info->name, "modbus1") == 0) {
EXPECT_STREQ("1!400001", info->address);
EXPECT_EQ(3, info->type);
EXPECT_EQ(1, info->attribute);
EXPECT_EQ(1, info->id);
} else if (strcmp(info->name, "modbus2") == 0) {
EXPECT_STREQ("1!400002", info->address);
EXPECT_EQ(4, info->type);
EXPECT_EQ(1, info->attribute);
EXPECT_EQ(2, info->id);
} else if (strcmp(info->name, "modbus3") == 0) {
EXPECT_STREQ("1!400003", info->address);
EXPECT_EQ(5, info->type);
EXPECT_EQ(1, info->attribute);
EXPECT_EQ(3, info->id);
} else {
EXPECT_EQ(1, 2);
}
free(info->name);
free(info->address);
}
vector_free(tags);
free(adapter_name);
vector_free(vec);
free(req);
free((char *) persist_dir);
free((char *) adapters_fname);
free((char *) plugins_fname);
free(persister);
free((char *) dir_name);
}
TEST(PersistenceSubscriptionTest, Subscription)
{
const char * dir_name = strdup("./persistence");
neu_persister_t *persister = neu_persister_create(dir_name);
const char * persist_dir = neu_persister_get_persist_dir(persister);
const char *adapters_fname = neu_persister_get_adapters_fname(persister);
const char *grp_config_name = "test-group";
const char *plugins_fname = neu_persister_get_plugins_fname(persister);
neu_json_subscriptions_req_subscription_t sub1 = {
(char *) "config_drv_sample", (char *) "sample-app-adapter", 2000,
(char *) "sample-driver-adapter"
};
neu_json_subscriptions_req_subscription_t sub2 = {
(char *) "config_app_sample", (char *) "mqtt-adapter", 2000,
(char *) "config_app_sample"
};
neu_json_subscriptions_req_subscription_t sub3 = {
(char *) "config_modbus_tcp_sample_2", (char *) "mqtt-adapter", 2000,
(char *) "modbus_tcp_adapter"
};
neu_json_subscriptions_req_t *req = (neu_json_subscriptions_req_t *) malloc(
sizeof(neu_json_subscriptions_req_t));
req->subscriptions = (neu_json_subscriptions_req_subscription_t *) calloc(
3, sizeof(neu_json_subscriptions_req_subscription_t));
req->n_subscription = 3;
req->subscriptions[0] = sub1;
req->subscriptions[1] = sub2;
req->subscriptions[2] = sub3;
char * adapter_name = strdup("adapter_mqtt");
vector_t *vec = vector_new_move_from_buf(
req->subscriptions, req->n_subscription, req->n_subscription,
sizeof(neu_json_subscriptions_req_subscription_t));
EXPECT_EQ(0,
neu_persister_store_subscriptions(persister, adapter_name, vec));
vector_t *subs = NULL;
EXPECT_EQ(0,
neu_persister_load_subscriptions(persister, adapter_name, &subs));
VECTOR_FOR_EACH(subs, iter)
{
neu_json_subscriptions_req_subscription_t *info =
(neu_json_subscriptions_req_subscription_t *) iterator_get(&iter);
if (strcmp(info->group_config_name, "config_drv_sample") == 0) {
EXPECT_STREQ("sample-app-adapter", info->sub_adapter_name);
EXPECT_EQ(2000, info->read_interval);
EXPECT_STREQ("sample-driver-adapter", info->src_adapter_name);
} else if (strcmp(info->group_config_name, "config_app_sample") == 0) {
EXPECT_STREQ("mqtt-adapter", info->sub_adapter_name);
EXPECT_EQ(2000, info->read_interval);
EXPECT_STREQ("config_app_sample", info->src_adapter_name);
} else if (strcmp(info->group_config_name,
"config_modbus_tcp_sample_2") == 0) {
EXPECT_STREQ("mqtt-adapter", info->sub_adapter_name);
EXPECT_EQ(2000, info->read_interval);
EXPECT_STREQ("modbus_tcp_adapter", info->src_adapter_name);
} else {
EXPECT_EQ(1, 2);
}
free(info->group_config_name);
free(info->sub_adapter_name);
free(info->src_adapter_name);
}
vector_free(subs);
free((char *) dir_name);
free((char *) persist_dir);
free((char *) adapters_fname);
free((char *) plugins_fname);
free(persister);
free(req);
free(adapter_name);
vector_free(vec);
}
int main(int argc, char **argv)
{
zlog_init("./config/dev.conf");
neuron = zlog_get_category("neuron");
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}