Merge remote-tracking branch 'origin/main-1' into main-1

plugins/restful/adapter_handle.c

@@ -335,8 +335,6 @@ void handle_get_node_state_resp(nng_aio *aio, neu_resp_get_node_state_t *state)
     res.rtt       = state->rtt;
     res.log_level = state->state.log_level;
     strcpy(res.core_level, state->core_level);
-    printf("!!!!!!!!!!!!!!!!!!%s\n", state->core_level);
-    printf("@@@@@@@@@@@@@@%s\n", res.core_level);
 
     neu_json_encode_by_fn(&res, neu_json_encode_get_node_state_resp, &result);
 

plugins/restful/log_handle.c

@@ -148,10 +148,10 @@ void handle_log_level(nng_aio *aio)
             }
             if (req->core) {
                 zlog_category_t *neuron = zlog_get_category("neuron");
-                ret = zlog_level_switch(neuron, log_level);
+                ret                     = zlog_level_switch(neuron, log_level);
                 if (ret != 0) {
-                    nlog_error("Failed to modify log_level of the core, ret: %d",
-                               ret);
+                    nlog_error(
+                        "Failed to modify log_level of the core, ret: %d", ret);
                     NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
                         neu_http_response(aio, error_code.error, result_error);
                     });
@@ -178,7 +178,7 @@ void handle_log_level(nng_aio *aio)
             header.ctx  = aio;
             header.type = NEU_REQ_UPDATE_LOG_LEVEL;
             cmd.core    = req->core;
-            ret = neu_plugin_op(plugin, header, &cmd);
+            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);

plugins/restful/rest.c

@@ -219,7 +219,6 @@ static int dashb_plugin_request(neu_plugin_t *      plugin,
                                     (neu_resp_get_nodes_state_t *) data);
         break;
     case NEU_RESP_GET_NODE_STATE:
-    printf("$$$$$$$$$$$$$$$$$$$$$$%s\n", ((neu_resp_get_node_state_t *)data)->core_level);
         handle_get_node_state_resp(header->ctx,
                                    (neu_resp_get_node_state_t *) data);
         break;

src/adapter/adapter.c

@@ -771,14 +771,15 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_GET_NODE_STATE: {
-        neu_resp_get_node_state_t *resp = (neu_resp_get_node_state_t *) &header[1];
+        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);

src/core/manager.c

@@ -1160,10 +1160,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_GET_NODES_STATE: {
         neu_resp_get_nodes_state_t resp = { 0 };
         UT_array *states = neu_node_manager_get_state(manager->node_manager);
-        
-        neu_adapter_t *adapter_core = neu_node_manager_find(manager->node_manager, "default-dashboard");
+
+        neu_adapter_t *adapter_core =
+            neu_node_manager_find(manager->node_manager, "default-dashboard");
         strcpy(resp.core_level,
-                neu_plugin_to_plugin_common(adapter_core->plugin)->log_level);
+               neu_plugin_to_plugin_common(adapter_core->plugin)->log_level);
         resp.states = utarray_clone(states);
 
         strcpy(header->receiver, header->sender);
@@ -1218,10 +1219,13 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(manager, header, &e);
         } else {
-            neu_resp_get_node_state_t *resp = (neu_resp_get_node_state_t *) &header[1];
-            neu_adapter_t *adapter_core = neu_node_manager_find(manager->node_manager, "default-dashboard");
-            strcpy(resp->core_level,
-                    neu_plugin_to_plugin_common(adapter_core->plugin)->log_level);
+            neu_resp_get_node_state_t *resp =
+                (neu_resp_get_node_state_t *) &header[1];
+            neu_adapter_t *adapter_core = neu_node_manager_find(
+                manager->node_manager, "default-dashboard");
+            strcpy(
+                resp->core_level,
+                neu_plugin_to_plugin_common(adapter_core->plugin)->log_level);
             forward_msg(manager, header, header->receiver);
         }
 
@@ -1482,65 +1486,68 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         }
         break;
     }
-    case NEU_REQ_UPDATE_LOG_LEVEL:
+    case NEU_REQ_UPDATE_LOG_LEVEL: {
         neu_req_update_log_level_t *cmd =
             (neu_req_update_log_level_t *) &header[1];
 
         if (cmd->core) {
             if (strcmp(header->receiver, "") == 0) {
-                neu_adapter_t *adapter_core = neu_node_manager_find(manager->node_manager, "default-dashboard");
-                strcpy(neu_plugin_to_plugin_common(adapter_core->plugin)->log_level,
-                        cmd->log_level);
+                neu_adapter_t *adapter_core = neu_node_manager_find(
+                    manager->node_manager, "default-dashboard");
+                strcpy(neu_plugin_to_plugin_common(adapter_core->plugin)
+                           ->log_level,
+                       cmd->log_level);
                 neu_resp_error_t error = { 0 };
                 neu_msg_exchange(header);
                 header->type = NEU_RESP_ERROR;
                 reply(manager, header, &error);
             } else {
-                if (neu_node_manager_find(manager->node_manager, header->receiver) ==
-                    NULL) {
+                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 {
-                    neu_adapter_t *adapter_core = neu_node_manager_find(manager->node_manager, "default-dashboard");
-                    strcpy(neu_plugin_to_plugin_common(adapter_core->plugin)->log_level,
-                            cmd->log_level);
-                    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);
+                    neu_adapter_t *adapter_core = neu_node_manager_find(
+                        manager->node_manager, "default-dashboard");
+                    strcpy(neu_plugin_to_plugin_common(adapter_core->plugin)
+                               ->log_level,
+                           cmd->log_level);
+                    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);
                 }
             }
         } else {
             if (strcmp(header->receiver, "") == 0) {
-                    neu_resp_error_t e = { .error = NEU_ERR_PARAM_IS_WRONG };
-                    header->type       = NEU_RESP_ERROR;
-                    neu_msg_exchange(header);
-                    reply(manager, header, &e);
+                neu_resp_error_t e = { .error = NEU_ERR_PARAM_IS_WRONG };
+                header->type       = NEU_RESP_ERROR;
+                neu_msg_exchange(header);
+                reply(manager, header, &e);
             } else {
-                if (neu_node_manager_find(manager->node_manager, header->receiver) ==
-                    NULL) {
+                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 {
-                    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);
+                    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;

src/parser/neu_json_log.c

@@ -45,19 +45,21 @@ int neu_json_decode_update_log_level_req(
     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,
-                                    }};
+    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);

src/parser/neu_json_node.c

@@ -240,17 +240,16 @@ int neu_json_encode_get_nodes_state_resp(void *json_object, void *param)
         p_node++;
     }
 
-    neu_json_elem_t resp_elems[] = {
-        {
-        .name         = "states",
-        .t            = NEU_JSON_OBJECT,
-        .v.val_object = node_array,
-        },
-        {
-        .name      = "neuron_core",
-        .t         = NEU_JSON_STR,
-        .v.val_str = resp->core_level,
-        }};
+    neu_json_elem_t resp_elems[] = { {
+                                         .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));
 

tests/ft/log/test_log.py

@@ -14,7 +14,7 @@ class TestLog:
         assert 200 == response.status_code
         assert 0 == response.json()['error']
 
-        response = api.change_log_level(node='modbus-tcp-1', level='debug')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'debug'})
         assert 200 == response.status_code
         assert 0 == response.json()['error']
 
@@ -24,7 +24,7 @@ class TestLog:
 
     @description(given="node", when="change log_level to info", then="change success")
     def test_change_log_level_info(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='info')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'info'})
         assert 0 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
@@ -33,7 +33,7 @@ class TestLog:
 
     @description(given="node", when="change log_level to warn", then="change success")
     def test_change_log_level_warn(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='warn')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'warn'})
         assert 0 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
@@ -42,7 +42,7 @@ class TestLog:
 
     @description(given="node", when="change log_level to error", then="change success")
     def test_change_log_level_error(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='error')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'error'})
         assert 0 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
@@ -51,7 +51,7 @@ class TestLog:
 
     @description(given="node", when="change log_level to fatal", then="change success")
     def test_change_log_level_fatal(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='fatal')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'fatal'})
         assert 0 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
@@ -60,7 +60,7 @@ class TestLog:
 
     @description(given="node", when="change log_level to notice", then="change success")
     def test_change_log_level_notice(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='notice')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'notice'})
         assert 0 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
@@ -69,10 +69,56 @@ class TestLog:
 
     @description(given="node", when="change log_level to invalid level", then="change failed")
     def test_change_log_level_invalid(self):
-        response = api.change_log_level(node='modbus-tcp-1', level='invalid')
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'invalid'})
         assert 400 == response.status_code
         assert 1003 == response.json()['error']
 
         response = api.get_nodes_state('modbus-tcp-1')
         assert 200 == response.status_code
         assert "notice" == response.json()['log_level']
+
+    @description(given="core=true, without node", when="change core log_level", then="change success")
+    def test_change_core_log_level_only(self):
+        response = api.change_log_level(json={"level": 'info', "core": True})
+        assert 0 == response.json()['error']
+
+        response = api.get_nodes_state('modbus-tcp-1')
+        assert 200 == response.status_code
+        assert "info" == response.json()['neuron_core']
+        assert "notice" == response.json()['log_level']
+
+    @description(given="core=false, without node", when="change core log_level", then="return error")
+    def test_change_log_level_err_param(self):
+        response = api.change_log_level(json={"level": 'info', "core": False})
+        assert 400 == response.status_code
+        assert 1003 == response.json()['error']
+
+    @description(given="without core, node exists", when="change core and node log_level", then="change success")
+    def test_change_core_node_log_level_without_core(self):
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'warn'})
+        assert 0 == response.json()['error']
+
+        response = api.get_nodes_state('modbus-tcp-1')
+        assert 200 == response.status_code
+        assert "warn" == response.json()['neuron_core']
+        assert "warn" == response.json()['log_level']
+
+    @description(given="core=true, node exists", when="change core and node log_level", then="change success")
+    def test_change_core_node_log_level(self):
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'notice', "core": True})
+        assert 0 == response.json()['error']
+
+        response = api.get_nodes_state('modbus-tcp-1')
+        assert 200 == response.status_code
+        assert "notice" == response.json()['neuron_core']
+        assert "notice" == response.json()['log_level']
+
+    @description(given="core=false, node exists", when="change node log_level", then="change success")
+    def test_change_node_log_level_only(self):
+        response = api.change_log_level(json={"node": 'modbus-tcp-1', "level": 'info', "core": False})
+        assert 0 == response.json()['error']
+
+        response = api.get_nodes_state('modbus-tcp-1')
+        assert 200 == response.status_code
+        assert "notice" == response.json()['neuron_core']
+        assert "info" == response.json()['log_level']

tests/ft/neuron/api.py

@@ -53,8 +53,8 @@ def delete_virtual_license(jwt=config.default_jwt):
 
 
 @gen_check
-def change_log_level(node, level, jwt=config.default_jwt):
-    return requests.put(url=config.BASE_URL + '/api/v2/log/level', headers={"Authorization": jwt}, json={"node": node, "level": level})
+def change_log_level(json, jwt=config.default_jwt):
+    return requests.put(url=config.BASE_URL + '/api/v2/log/level', headers={"Authorization": jwt}, json=json)
 
 
 @gen_check