feat(tag):supports renaming tags

include/neuron/msg.h

@@ -114,6 +114,8 @@ typedef enum neu_reqresp_type {
     NEU_RESP_UPDATE_TAG,
     NEU_REQ_GET_TAG,
     NEU_RESP_GET_TAG,
+    NEU_REQ_RENAME_TAG,
+    NEU_RESP_RENAME_TAG,
 
     NEU_REQ_ADD_PLUGIN,
     NEU_REQ_DEL_PLUGIN,
@@ -169,6 +171,7 @@ typedef enum neu_reqresp_type {
     NEU_REQ_ADD_TAG_EVENT,
     NEU_REQ_DEL_TAG_EVENT,
     NEU_REQ_UPDATE_TAG_EVENT,
+    NEU_REQ_RENAME_TAG_EVENT,
     NEU_REQ_IMPORT_TAGS_EVENT,
 
     NEU_REQ_ADD_GTAG_EVENT,
@@ -279,6 +282,8 @@ static const char *neu_reqresp_type_string_t[] = {
     [NEU_RESP_UPDATE_TAG]  = "NEU_RESP_UPDATE_TAG",
     [NEU_REQ_GET_TAG]      = "NEU_REQ_GET_TAG",
     [NEU_RESP_GET_TAG]     = "NEU_RESP_GET_TAG",
+    [NEU_REQ_RENAME_TAG]   = "NEU_REQ_RENAME_TAG",
+    [NEU_RESP_RENAME_TAG]  = "NEU_RESP_RENAME_TAG",
 
     [NEU_REQ_ADD_PLUGIN]    = "NEU_REQ_ADD_PLUGIN",
     [NEU_REQ_DEL_PLUGIN]    = "NEU_REQ_DEL_PLUGIN",
@@ -333,6 +338,7 @@ static const char *neu_reqresp_type_string_t[] = {
     [NEU_REQ_ADD_TAG_EVENT]           = "NEU_REQ_ADD_TAG_EVENT",
     [NEU_REQ_DEL_TAG_EVENT]           = "NEU_REQ_DEL_TAG_EVENT",
     [NEU_REQ_UPDATE_TAG_EVENT]        = "NEU_REQ_UPDATE_TAG_EVENT",
+    [NEU_REQ_RENAME_TAG_EVENT]        = "NEU_REQ_RENAME_TAG_EVENT",
     [NEU_REQ_IMPORT_TAGS_EVENT]       = "NEU_REQ_IMPORT_TAGS_EVENT",
     [NEU_REQ_ADD_GTAG_EVENT]          = "NEU_REQ_ADD_GTAG_EVENT",
     [NEU_REQ_ADD_PLUGIN_EVENT]        = "NEU_REQ_ADD_PLUGIN_EVENT",
@@ -730,6 +736,17 @@ typedef struct neu_resp_get_tag {
     UT_array *tags; // array neu_datatag_t
 } neu_resp_get_tag_t;
 
+typedef struct {
+    char driver[NEU_NODE_NAME_LEN];
+    char group[NEU_GROUP_NAME_LEN];
+    char old_name[NEU_TAG_NAME_LEN];
+    char new_name[NEU_TAG_NAME_LEN];
+} neu_req_rename_tag_t;
+
+typedef struct {
+    int error;
+} neu_resp_rename_tag_t;
+
 typedef struct {
     char     app[NEU_NODE_NAME_LEN];
     char     driver[NEU_NODE_NAME_LEN];

include/neuron/persist/persist.h

@@ -333,6 +333,17 @@ int neu_persister_update_tag_value(const char *         driver_name,
 int neu_persister_delete_tag(const char *driver_name, const char *group_name,
                              const char *tag_name);
 
+/**
+ * Rename node tag.
+ * @param driver_name               name of the driver who owns the tags
+ * @param group_name                name of the group
+ * @param old_name                  old name of the tag
+ * @param new_name                  new name of the tag
+ * @return 0 on success, non-zero otherwise
+ */
+int neu_persister_rename_tag(const char *driver_name, const char *group_name,
+                             const char *old_name, const char *new_name);
+
 /**
  * Persist subscriptions.
  * @param app_name                  name of the app node

plugins/restful/datatag_handle.c

@@ -398,6 +398,72 @@ void handle_update_tags_resp(nng_aio *aio, neu_resp_update_tag_t *resp)
     handle_add_tags_resp(aio, resp);
 }
 
+void handle_rename_tag(nng_aio *aio)
+{
+    neu_plugin_t *plugin = neu_rest_get_plugin();
+
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
+        aio, neu_json_rename_tag_req_t, neu_json_decode_rename_tag_req, {
+            int                  ret    = 0;
+            neu_reqresp_head_t   header = { 0 };
+            neu_req_rename_tag_t cmd    = { 0 };
+            int                  err_type;
+
+            header.ctx             = aio;
+            header.type            = NEU_REQ_RENAME_TAG;
+            header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
+
+            if (strlen(req->node) >= NEU_NODE_NAME_LEN) {
+                err_type = NEU_ERR_NODE_NAME_TOO_LONG;
+                goto error;
+            }
+
+            if (strlen(req->group) >= NEU_GROUP_NAME_LEN) {
+                err_type = NEU_ERR_GROUP_NAME_TOO_LONG;
+                goto error;
+            }
+
+            if (strlen(req->old_name) == 0 || strlen(req->new_name) == 0) {
+                err_type = NEU_ERR_PARAM_IS_WRONG;
+                goto error;
+            }
+
+            if (strlen(req->old_name) >= NEU_TAG_NAME_LEN) {
+                err_type = NEU_ERR_TAG_NAME_TOO_LONG;
+                goto error;
+            }
+
+            if (strlen(req->new_name) >= NEU_TAG_NAME_LEN) {
+                err_type = NEU_ERR_TAG_NAME_TOO_LONG;
+                goto error;
+            }
+
+            strcpy(cmd.driver, req->node);
+            strcpy(cmd.group, req->group);
+            strcpy(cmd.old_name, req->old_name);
+            strcpy(cmd.new_name, req->new_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);
+                });
+            }
+            goto success;
+
+        error:
+            NEU_JSON_RESPONSE_ERROR(
+                err_type, { neu_http_response(aio, err_type, result_error); });
+        success:;
+        })
+}
+
+void handle_rename_tag_resp(nng_aio *aio, neu_resp_rename_tag_t *resp)
+{
+    NEU_JSON_RESPONSE_ERROR(
+        resp->error, { neu_http_response(aio, resp->error, result_error); });
+}
+
 void handle_get_tags(nng_aio *aio)
 {
     neu_plugin_t *     plugin                     = neu_rest_get_plugin();

plugins/restful/datatag_handle.h

@@ -33,6 +33,8 @@ void handle_import_tags_resp(nng_aio *aio, neu_resp_add_tag_t *resp);
 void handle_del_tags(nng_aio *aio);
 void handle_update_tags(nng_aio *aio);
 void handle_update_tags_resp(nng_aio *aio, neu_resp_update_tag_t *resp);
+void handle_rename_tag(nng_aio *aio);
+void handle_rename_tag_resp(nng_aio *aio, neu_resp_rename_tag_t *resp);
 void handle_get_tags(nng_aio *aio);
 void handle_get_tags_resp(nng_aio *aio, neu_resp_get_tag_t *tags);
 

plugins/restful/handle.c

@@ -212,6 +212,9 @@ static struct neu_http_handler cors_handler[] = {
     {
         .url = "/api/v2/simulator/export",
     },
+    {
+        .url = "/api/v2/tag/rename",
+    },
 };
 
 static struct neu_http_handler rest_handlers[] = {
@@ -294,6 +297,12 @@ static struct neu_http_handler rest_handlers[] = {
         .url           = "/api/v2/tags",
         .value.handler = handle_del_tags,
     },
+    {
+        .method        = NEU_HTTP_METHOD_PUT,
+        .type          = NEU_HTTP_HANDLER_FUNCTION,
+        .url           = "/api/v2/tag/rename",
+        .value.handler = handle_rename_tag,
+    },
     {
         .method        = NEU_HTTP_METHOD_POST,
         .type          = NEU_HTTP_HANDLER_FUNCTION,

plugins/restful/rest.c

@@ -280,6 +280,13 @@ static int dashb_plugin_request(neu_plugin_t *      plugin,
                 scope, "error", ((neu_resp_update_tag_t *) data)->error);
         }
         break;
+    case NEU_RESP_RENAME_TAG:
+        handle_rename_tag_resp(header->ctx, (neu_resp_rename_tag_t *) data);
+        if (neu_otel_control_is_started() && trace) {
+            neu_otel_scope_add_span_attr_int(
+                scope, "error", ((neu_resp_rename_tag_t *) data)->error);
+        }
+        break;
     case NEU_RESP_GET_TAG:
         handle_get_tags_resp(header->ctx, (neu_resp_get_tag_t *) data);
         if (neu_otel_control_is_started() && trace) {

src/adapter/adapter.c

@@ -548,6 +548,11 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
         strcpy(pheader->receiver, cmd->driver);
         break;
     }
+    case NEU_REQ_RENAME_TAG: {
+        neu_req_rename_tag_t *cmd = (neu_req_rename_tag_t *) data;
+        strcpy(pheader->receiver, cmd->driver);
+        break;
+    }
     case NEU_REQ_IMPORT_TAGS: {
         neu_req_import_tags_t *cmd = (neu_req_import_tags_t *) data;
         strcpy(pheader->receiver, cmd->node);
@@ -887,6 +892,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_RESP_ADD_GTAG:
     case NEU_RESP_IMPORT_TAGS:
     case NEU_RESP_UPDATE_TAG:
+    case NEU_RESP_RENAME_TAG:
     case NEU_RESP_GET_TAG:
     case NEU_RESP_GET_NODE:
     case NEU_RESP_GET_PLUGIN:
@@ -912,6 +918,7 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_ADD_TAG_EVENT:
     case NEU_REQ_DEL_TAG_EVENT:
     case NEU_REQ_UPDATE_TAG_EVENT:
+    case NEU_REQ_RENAME_TAG_EVENT:
     case NEU_REQ_ADD_GTAG_EVENT:
     case NEU_REQ_ADD_PLUGIN_EVENT:
     case NEU_REQ_DEL_PLUGIN_EVENT:
@@ -1772,6 +1779,40 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         reply(adapter, header, &resp);
         break;
     }
+    case NEU_REQ_RENAME_TAG: {
+        neu_req_rename_tag_t *cmd  = (neu_req_rename_tag_t *) &header[1];
+        neu_resp_rename_tag_t resp = { 0 };
+
+        if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
+            resp.error = neu_adapter_driver_rename_tag(
+                (neu_adapter_driver_t *) adapter, cmd->group, cmd->old_name,
+                cmd->new_name);
+            if (resp.error == 0) {
+                rv = adapter_storage_rename_tag(cmd->driver, cmd->group,
+                                                cmd->old_name, cmd->new_name);
+                if (rv != 0) {
+                    // rollback in-memory rename on persistence failure
+                    nlog_error("persist rename failed, rolling back "
+                               "tag:%s->%s node:%s grp:%s",
+                               cmd->old_name, cmd->new_name, cmd->driver,
+                               cmd->group);
+                    neu_adapter_driver_rename_tag(
+                        (neu_adapter_driver_t *) adapter, cmd->group,
+                        cmd->new_name, cmd->old_name);
+                    resp.error = NEU_ERR_EINTERNAL;
+                } else if (header->monitor) {
+                    notify_monitor(adapter, NEU_REQ_RENAME_TAG_EVENT, cmd);
+                }
+            }
+        } else {
+            resp.error = NEU_ERR_GROUP_NOT_ALLOW;
+        }
+
+        neu_msg_exchange(header);
+        header->type = NEU_RESP_RENAME_TAG;
+        reply(adapter, header, &resp);
+        break;
+    }
     case NEU_REQ_NODE_UNINIT: {
         neu_req_node_uninit_t *cmd = (neu_req_node_uninit_t *) &header[1];
         char                   name[NEU_NODE_NAME_LEN]     = { 0 };

src/adapter/driver/cache.c

@@ -71,8 +71,8 @@ inline static tkey_t to_key(const char *group, const char *tag)
 {
     tkey_t key = { 0 };
 
-    strcpy(key.group, group);
-    strcpy(key.tag, tag);
+    strncpy(key.group, group, sizeof(key.group) - 1);
+    strncpy(key.tag, tag, sizeof(key.tag) - 1);
 
     return key;
 }
@@ -1266,3 +1266,21 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
 
     pthread_mutex_unlock(&cache->mtx);
 }
+
+void neu_driver_cache_rename(neu_driver_cache_t *cache, const char *group,
+                             const char *old_tag, const char *new_tag)
+{
+    struct elem *elem = NULL;
+    tkey_t       key  = to_key(group, old_tag);
+
+    pthread_mutex_lock(&cache->mtx);
+    HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
+
+    if (elem != NULL) {
+        HASH_DEL(cache->table, elem);
+        elem->key = to_key(group, new_tag);
+        HASH_ADD(hh, cache->table, key, sizeof(tkey_t), elem);
+    }
+
+    pthread_mutex_unlock(&cache->mtx);
+}

src/adapter/driver/cache.h

@@ -43,6 +43,8 @@ bool neu_driver_cache_update_change(neu_driver_cache_t *cache,
 
 void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
                           const char *tag);
+void neu_driver_cache_rename(neu_driver_cache_t *cache, const char *group,
+                             const char *old_tag, const char *new_tag);
 
 void neu_driver_cache_update_trace(neu_driver_cache_t *cache, const char *group,
                                    void *trace_ctx);

src/adapter/driver/driver.c

@@ -2320,6 +2320,30 @@ int neu_adapter_driver_update_tag(neu_adapter_driver_t *driver,
     return ret;
 }
 
+int neu_adapter_driver_rename_tag(neu_adapter_driver_t *driver,
+                                  const char *group, const char *old_name,
+                                  const char *new_name)
+{
+    int      ret  = NEU_ERR_SUCCESS;
+    group_t *find = NULL;
+
+    if (strlen(new_name) >= NEU_TAG_NAME_LEN) {
+        return NEU_ERR_TAG_NAME_TOO_LONG;
+    }
+
+    HASH_FIND_STR(driver->groups, group, find);
+    if (find != NULL) {
+        ret = neu_group_rename_tag(find->group, old_name, new_name);
+        if (ret == NEU_ERR_SUCCESS) {
+            neu_driver_cache_rename(driver->cache, group, old_name, new_name);
+        }
+    } else {
+        ret = NEU_ERR_GROUP_NOT_EXIST;
+    }
+
+    return ret;
+}
+
 int neu_adapter_driver_get_tag(neu_adapter_driver_t *driver, const char *group,
                                UT_array **tags)
 {

src/adapter/driver/driver_internal.h

@@ -78,6 +78,9 @@ int neu_adapter_driver_del_tag(neu_adapter_driver_t *driver, const char *group,
                                const char *tag);
 int neu_adapter_driver_update_tag(neu_adapter_driver_t *driver,
                                   const char *group, neu_datatag_t *tag);
+int neu_adapter_driver_rename_tag(neu_adapter_driver_t *driver,
+                                  const char *group, const char *old_name,
+                                  const char *new_name);
 int neu_adapter_driver_get_tag(neu_adapter_driver_t *driver, const char *group,
                                UT_array **tags);
 UT_array *neu_adapter_driver_get_ptag(neu_adapter_driver_t *driver,

src/adapter/storage.c

@@ -127,6 +127,17 @@ void adapter_storage_del_tag(const char *node, const char *group,
     }
 }
 
+int adapter_storage_rename_tag(const char *node, const char *group,
+                               const char *old_name, const char *new_name)
+{
+    int rv = neu_persister_rename_tag(node, group, old_name, new_name);
+    if (0 != rv) {
+        nlog_error("fail rename tag:%s->%s adapter:%s grp:%s", old_name,
+                   new_name, node, group);
+    }
+    return rv;
+}
+
 int adapter_load_setting(const char *node, char **setting)
 {
     int rv = neu_persister_load_node_setting(node, (const char **) setting);

src/adapter/storage.h

@@ -41,6 +41,8 @@ void adapter_storage_update_tag_value(const char *node, const char *group,
                                       const neu_datatag_t *tag);
 void adapter_storage_del_tag(const char *node, const char *group,
                              const char *name);
+int  adapter_storage_rename_tag(const char *node, const char *group,
+                                const char *old_name, const char *new_name);
 
 int adapter_load_setting(const char *node, char **setting);
 int adapter_load_group_and_tag(neu_adapter_driver_t *driver);