Merge pull request #2350 from fengzeroz/v2.10

version: 2.10.2

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
       - published
 
 env:
-  VERSION: 2.10.1
+  VERSION: 2.10.2
   UI_VERSION: 2.6.1
   BRANCH: v2.10
 

CMakeLists.txt

@@ -166,8 +166,6 @@ file(COPY ${CMAKE_SOURCE_DIR}/dev.conf DESTINATION ${CMAKE_BINARY_DIR}/config)
 file(COPY ${CMAKE_SOURCE_DIR}/neuron.json DESTINATION ${CMAKE_BINARY_DIR}/config)
 file(COPY ${CMAKE_SOURCE_DIR}/.gitkeep DESTINATION ${CMAKE_BINARY_DIR}/logs)
 file(COPY ${CMAKE_SOURCE_DIR}/.gitkeep DESTINATION ${CMAKE_BINARY_DIR}/persistence)
-file(COPY ${CMAKE_SOURCE_DIR}/neuron.key DESTINATION ${CMAKE_BINARY_DIR}/config)
-file(COPY ${CMAKE_SOURCE_DIR}/neuron.pem DESTINATION ${CMAKE_BINARY_DIR}/config)
 file(GLOB SQL_SCHEMAS ${CMAKE_SOURCE_DIR}/persistence/*.sql)
 file(COPY ${SQL_SCHEMAS} DESTINATION ${CMAKE_BINARY_DIR}/config)
 file(COPY ${CMAKE_SOURCE_DIR}/default_plugins.json DESTINATION ${CMAKE_BINARY_DIR}/config)

include/neuron/connection/neu_connection.h

@@ -254,6 +254,8 @@ ssize_t neu_conn_recv(neu_conn_t *conn, uint8_t *buf, ssize_t len);
 ssize_t neu_conn_udp_recvfrom(neu_conn_t *conn, uint8_t *buf, ssize_t len,
                               void *src);
 
+void neu_conn_clear_recv_buffer(neu_conn_t *conn);
+
 /**
  * @brief Specify the client to send data.
  *

include/neuron/define.h

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

include/neuron/json/neu_json_rw.h

@@ -63,6 +63,7 @@ typedef struct {
 
 int neu_json_encode_read_resp(void *json_object, void *param);
 int neu_json_encode_read_resp1(void *json_object, void *param);
+int neu_json_encode_read_resp2(void *json_object, void *param);
 int neu_json_encode_read_paginate_resp(void *json_object, void *param);
 
 typedef struct {

package-sdk.sh

@@ -51,8 +51,6 @@ cp persistence/*.sql ${package_name}/config/
 cp sdk-zlog.conf ${package_name}/config/
 cp zlog.conf ${package_name}/config/
 cp dev.conf ${package_name}/config/
-cp neuron.key ${package_name}/config/
-cp neuron.pem ${package_name}/config/
 cp default_plugins.json ${package_name}/config/
 cp neuron.json ${package_name}/config/
 

plugins/modbus/modbus_req.c

@@ -113,6 +113,8 @@ int modbus_send_msg(void *ctx, uint16_t n_byte, uint8_t *bytes)
     neu_plugin_t *plugin = (neu_plugin_t *) ctx;
     int           ret    = 0;
 
+    neu_conn_clear_recv_buffer(plugin->conn);
+
     plog_send_protocol(plugin, bytes, n_byte);
 
     if (plugin->is_server) {

plugins/mqtt/mqtt_handle.c

@@ -82,7 +82,7 @@ char *generate_upload_json(neu_plugin_t *plugin, neu_reqresp_trans_data_t *data,
                                   neu_json_encode_read_periodic_resp,
                                   &json_str);
     } else if (MQTT_UPLOAD_FORMAT_TAGS == format) { // tags
-        neu_json_encode_with_mqtt(&json, neu_json_encode_read_resp, &header,
+        neu_json_encode_with_mqtt(&json, neu_json_encode_read_resp2, &header,
                                   neu_json_encode_read_periodic_resp,
                                   &json_str);
     } else {

sdk-install.sh

@@ -25,8 +25,6 @@ mkdir -p ${neuron_bin}/plugins
 cp ./neuron ${neuron_bin}/
 cp config/sdk-zlog.conf ${neuron_bin}/config/zlog.conf
 cp config/dev.conf ${neuron_bin}/config/
-cp config/neuron.key ${neuron_bin}/config/
-cp config/neuron.pem ${neuron_bin}/config/
 cp config/default_plugins.json ${neuron_bin}/config/
 cp config/*.sql ${neuron_bin}/config/
 

src/adapter/driver/driver.c

@@ -834,7 +834,6 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
         break;
     case NEU_TYPE_BYTES:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.bytes.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.bytes.bytes[i] =
                     (uint8_t) value->value.i64s.i64s[i];
@@ -842,44 +841,44 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.bytes.bytes[i] = 0;
             }
+            value->value.bytes.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_INT8:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.i8s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.i8s.i8s[i] = (int8_t) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.i8s.i8s[i] = 0;
             }
+            value->value.i8s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_UINT8:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.u8s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.u8s.u8s[i] = (uint8_t) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.u8s.u8s[i] = 0;
             }
+            value->value.u8s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_INT16:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.i16s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.i16s.i16s[i] = (int16_t) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.i16s.i16s[i] = 0;
             }
+            value->value.i16s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_UINT16:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.u16s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.u16s.u16s[i] =
                     (uint16_t) value->value.i64s.i64s[i];
@@ -887,22 +886,22 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.u16s.u16s[i] = 0;
             }
+            value->value.u16s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_INT32:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.i32s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.i32s.i32s[i] = (int32_t) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.i32s.i32s[i] = 0;
             }
+            value->value.i32s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_UINT32:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.u32s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.u32s.u32s[i] =
                     (uint32_t) value->value.i64s.i64s[i];
@@ -910,11 +909,11 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.u32s.u32s[i] = 0;
             }
+            value->value.u32s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_UINT64:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.u64s.length = value->value.i64s.length;
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.u64s.u64s[i] =
                     (uint64_t) value->value.i64s.i64s[i];
@@ -922,37 +921,41 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.u64s.u64s[i] = 0;
             }
+            value->value.u64s.length = value->value.i64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_FLOAT:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.f32s.length = value->value.i64s.length;
+
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.f32s.f32s[i] = (float) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.f32s.f32s[i] = 0;
             }
+            value->value.f32s.length = value->value.i64s.length;
         }
         if (value->type == NEU_TYPE_ARRAY_DOUBLE) {
-            value->value.f32s.length = value->value.f64s.length;
+
             for (int i = 0; i < value->value.f64s.length; i++) {
                 value->value.f32s.f32s[i] = (float) value->value.f64s.f64s[i];
             }
             for (int i = value->value.f64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.f32s.f32s[i] = 0;
             }
+            value->value.f32s.length = value->value.f64s.length;
         }
         break;
     case NEU_TYPE_ARRAY_DOUBLE:
         if (value->type == NEU_TYPE_ARRAY_INT64) {
-            value->value.f64s.length = value->value.i64s.length;
+
             for (int i = 0; i < value->value.i64s.length; i++) {
                 value->value.f64s.f64s[i] = (double) value->value.i64s.i64s[i];
             }
             for (int i = value->value.i64s.length; i < NEU_VALUE_SIZE; i++) {
                 value->value.f64s.f64s[i] = 0;
             }
+            value->value.f64s.length = value->value.i64s.length;
         }
         break;
     default:

src/connection/connection.c

@@ -407,6 +407,40 @@ ssize_t neu_conn_send(neu_conn_t *conn, uint8_t *buf, ssize_t len)
     return ret;
 }
 
+void neu_conn_clear_recv_buffer(neu_conn_t *conn)
+{
+    if (!conn->is_connected) {
+        return;
+    }
+
+    uint8_t temp_buf[256];
+    ssize_t ret;
+
+    switch (conn->param.type) {
+    case NEU_CONN_TCP_CLIENT:
+        do {
+            ret = recv(conn->fd, temp_buf, sizeof(temp_buf), MSG_DONTWAIT);
+
+            if (ret > 0) {
+                continue;
+            } else if (ret == 0) {
+                zlog_info(conn->param.log,
+                          "Connection closed while clearing buffer.");
+                break;
+            } else if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                break;
+            } else {
+                zlog_error(conn->param.log, "Error clearing buffer: %s",
+                           strerror(errno));
+                break;
+            }
+        } while (ret > 0);
+        break;
+    default:
+        break;
+    }
+}
+
 ssize_t neu_conn_recv(neu_conn_t *conn, uint8_t *buf, ssize_t len)
 {
     ssize_t ret = 0;

src/parser/neu_json_rw.c

@@ -291,6 +291,53 @@ int neu_json_encode_read_resp1(void *json_object, void *param)
     return ret;
 }
 
+int neu_json_encode_read_resp2(void *json_object, void *param)
+{
+    int                   ret  = 0;
+    neu_json_read_resp_t *resp = (neu_json_read_resp_t *) param;
+
+    void *                    tag_array = neu_json_array();
+    neu_json_read_resp_tag_t *p_tag     = resp->tags;
+    for (int i = 0; i < resp->n_tag; i++) {
+        neu_json_elem_t tag_elems[2 + NEU_TAG_META_SIZE] = { 0 };
+
+        tag_elems[0].name      = "name";
+        tag_elems[0].t         = NEU_JSON_STR;
+        tag_elems[0].v.val_str = p_tag->name;
+
+        if (p_tag->error != 0) {
+            tag_elems[1].name      = "error";
+            tag_elems[1].t         = NEU_JSON_INT;
+            tag_elems[1].v.val_int = p_tag->error;
+        } else {
+            tag_elems[1].name      = "value";
+            tag_elems[1].t         = p_tag->t;
+            tag_elems[1].v         = p_tag->value;
+            tag_elems[1].precision = p_tag->precision;
+        }
+
+        for (int k = 0; k < p_tag->n_meta; k++) {
+            tag_elems[2 + k].name = p_tag->metas[k].name;
+            tag_elems[2 + k].t    = p_tag->metas[k].t;
+            tag_elems[2 + k].v    = p_tag->metas[k].value;
+        }
+
+        tag_array =
+            neu_json_encode_array(tag_array, tag_elems, 2 + p_tag->n_meta);
+        p_tag++;
+    }
+
+    neu_json_elem_t resp_elems[] = { {
+        .name         = "tags",
+        .t            = NEU_JSON_OBJECT,
+        .v.val_object = tag_array,
+    } };
+    ret = neu_json_encode_field(json_object, resp_elems,
+                                NEU_JSON_ELEM_SIZE(resp_elems));
+
+    return ret;
+}
+
 int neu_json_decode_write_req(char *buf, neu_json_write_req_t **result)
 {
     void *json_obj = neu_json_decode_new(buf);

src/utils/neu_jwt.c

@@ -43,6 +43,46 @@ static struct public_key_store key_store;
 static char                    neuron_private_key[2048] = { 0 };
 static char                    neuron_public_key[2048]  = { 0 };
 
+static const char *private_key_content =
+    "-----BEGIN RSA PRIVATE KEY-----\n"
+    "MIIEpAIBAAKCAQEAzrO7FUz4GGKl4nP5lwKMh5uageJAAHnLZpVxTR1wXA9E870s\n"
+    "U03gHnPWsh2bXCCx85ymYaiu/5VlptgnU0rQB1I3xGRG8eHmHPrhHNWDRKpY6oY8\n"
+    "AnTPqXvfa/Z4u+njJzDSqi4qM8Gwfqlgpjlg8DUF+sheLx8hL+x9XFzovTxafrmy\n"
+    "JRRAVQTkhB7esKKqRF8BMjdOdYZxJEv9jxa0BwXcjprPDlj5TV6k3wJqbq4UtnEE\n"
+    "VbjEQKqFVkfY4FuJ5NSPHpGEix94PGQGRsiWkGX0vx5udHJ0SlXM6qpMLny18FhW\n"
+    "bwKNX3urc3mImn/j3zcJ5x1d+FlXAXs1NBSeTQIDAQABAoIBAQDJOT8PZXbAhohn\n"
+    "A/AeimS0P08S0mbsD6VroGBEajxP4q2FeswD7PQZsTt4+kmcTlfuiLmQqN50AcSL\n"
+    "wDHIbDRIbEnN7rECGKAj5jfwEgtQdWVKKpOQ8JaYr/a466BtjyuLo4PyGC8NY6mm\n"
+    "JM3qBEHSlkvT7+uAhBWSye7gU7JfRPoCeFRpaMMC3Ad0DaIt/Pdt9CddNwj56+9j\n"
+    "gl//blNnBImjvA7/kh9gL69SYVrQoG9vm/UgFbdIwd+w2hhhpx6kuHjRJ21xIV/y\n"
+    "Yh9k4QhPr7zIkhQ8yn11ZhyZkMC8XAMy7NKCmAFIPNJ8jwvgBkunPEk2aYBeDUaq\n"
+    "a30VwlIhAoGBAOnm8DW5DROcfSj4Q8zsvgmvhGM0zzF5zmA+4E+tEbf4t6sDUjSs\n"
+    "ADo2EaiJZz75vLsD7UZHKzFEV/wnuT7SiNCbrJafx8Tp2UgijTkW8gEhAWREJDn5\n"
+    "FS375RKFdEcpmVHWgsuz4z/0L3BGxmyYWQxx5pD2NL49ZpTIHAHm/XETAoGBAOI6\n"
+    "8Y08TmM2bnXbL/MggYMJlqOyv27ueVYz9of3FYFAMIe7ebSgrlSCOwsoDZYmegBM\n"
+    "OrowR3AAnoP4fjGNbIPjNYbiv1qLOdtnvPxYotEz+ZaUBSn9V/gUEVFlgrKxgTKr\n"
+    "sqi/QMyyJplBTUkUuqYRDuv6TZ3OWKiDUoXTdv8fAoGBAIbbyf+PlESMY3Vtvtm2\n"
+    "XdODyRbR6ewiyKShW/9UT/T8iBknrwwDZ5YoeoHrxwV+RBynpPRyMCsVto0B8kKQ\n"
+    "bKWqPBYURb/4/Hgkw7v4yMtx1jWTPDfYryd2JptJKsOk7mtK/Nqp+wpypa9cfyc5\n"
+    "p44PVdqauco96Jk7zzohjlrVAoGAfjQDrJaH5DDpTjYIeckYdtFSh9+fi3LdnYk/\n"
+    "bnoYNRJqAE5Fhs5ccih0Z7TgX3L3fFMKL/Pe5kxyIYzuWRZcAvctVSIJPamNjShB\n"
+    "9UQ9EBe+lJHej54VBP+s6YuHbcg4GtxNvnVy4L5Bah1T0AEQXrQFbv8jbXU/YEJi\n"
+    "NuXQ7GECgYA0UNvuZxVSDn8fBxARcX3ub5aok5owdLL3SOCPMpNrmOBQj8iJGT+5\n"
+    "nv7fH1TWVh9yUdRwhd81s5H/PO3/myLmgq0TcPvewtEEwY+++QpsYZwHTDXgxbbw\n"
+    "++lmJali4fzmd/72JqocGABYhZFt0jbcQ1QEcqUYcD380+cNVZPO+w==\n"
+    "-----END RSA PRIVATE KEY-----\n";
+
+const char *public_key_content =
+    "-----BEGIN PUBLIC KEY-----\n"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzrO7FUz4GGKl4nP5lwKM\n"
+    "h5uageJAAHnLZpVxTR1wXA9E870sU03gHnPWsh2bXCCx85ymYaiu/5VlptgnU0rQ\n"
+    "B1I3xGRG8eHmHPrhHNWDRKpY6oY8AnTPqXvfa/Z4u+njJzDSqi4qM8Gwfqlgpjlg\n"
+    "8DUF+sheLx8hL+x9XFzovTxafrmyJRRAVQTkhB7esKKqRF8BMjdOdYZxJEv9jxa0\n"
+    "BwXcjprPDlj5TV6k3wJqbq4UtnEEVbjEQKqFVkfY4FuJ5NSPHpGEix94PGQGRsiW\n"
+    "kGX0vx5udHJ0SlXM6qpMLny18FhWbwKNX3urc3mImn/j3zcJ5x1d+FlXAXs1NBSe\n"
+    "TQIDAQAB\n"
+    "-----END PUBLIC KEY-----\n";
+
 static int find_key(const char *name)
 {
     for (int i = 0; i < key_store.size; i++) {
@@ -95,15 +135,13 @@ static char *load_key(const char *dir, char *name)
 
 static void load_neuron_key(const char *dir_path)
 {
-    char *content = load_key(dir_path, "neuron.key");
-    assert(content != NULL);
 
-    strncpy(neuron_private_key, content, sizeof(neuron_private_key) - 1);
+    (void) dir_path;
+    strncpy(neuron_private_key, private_key_content,
+            sizeof(neuron_private_key) - 1);
 
-    content = load_key(dir_path, "neuron.pem");
-    assert(content != NULL);
-
-    strncpy(neuron_public_key, content, sizeof(neuron_public_key) - 1);
+    strncpy(neuron_public_key, public_key_content,
+            sizeof(neuron_public_key) - 1);
 }
 
 static void scanf_key(const char *dir_path)

tests/ft/persist/test_persist.py

@@ -463,19 +463,12 @@ class TestPersist:
 
     @description(given="upload pem in certs", when="login", then="success")
     def test_jwt(self):
-        if not os.path.exists('./build/certs/'):
-            os.makedirs('./build/certs/')
-
-        shutil.copyfile('./build/config/neuron.pem', './build/certs/neuron.pem')
-
         p = process.NeuronProcess()
         p.start()
 
         response = api.login()
         assert 200 == response.status_code
 
-        shutil.rmtree('./build/certs/')
-
         p.stop()
 
     @description(given="new schema", when="upload schema , restart and add tags", then="success")

tests/ut/CMakeLists.txt

@@ -19,8 +19,6 @@ target_include_directories(http_test PRIVATE
 	${CMAKE_SOURCE_DIR}/plugins/restful)
 target_link_libraries(http_test neuron-base gtest_main gtest jansson nng)
 
-file(COPY ${CMAKE_SOURCE_DIR}/neuron.key DESTINATION ${UT_DIRECTORY}/config)
-file(COPY ${CMAKE_SOURCE_DIR}/neuron.pem DESTINATION ${UT_DIRECTORY}/config)
 add_executable(jwt_test jwt_test.cc)
 target_include_directories(jwt_test PRIVATE 
     ${CMAKE_SOURCE_DIR}/src 

version

@@ -1 +1 @@
-2.10.1
+2.10.2