feat(core): fulfill NEU_REQ_INST_TEMPLATE request

src/core/manager.c

@@ -450,6 +450,20 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         }
         break;
     }
+    case NEU_REQ_INST_TEMPLATE: {
+        neu_req_inst_template_t *cmd = (neu_req_inst_template_t *) &header[1];
+        neu_resp_error_t         e   = { 0 };
+
+        e.error = neu_manager_instantiate_template(manager, cmd);
+        if (NEU_ERR_SUCCESS == e.error) {
+            manager_storage_inst_node(manager, cmd->tmpl, cmd->node);
+        }
+
+        header->type = NEU_RESP_ERROR;
+        strcpy(header->receiver, header->sender);
+        reply(manager, header, &e);
+        break;
+    }
     case NEU_REQ_ADD_NODE: {
         neu_req_add_node_t *cmd = (neu_req_add_node_t *) &header[1];
         int                 error =

src/core/manager_internal.c

@@ -327,6 +327,72 @@ int neu_manager_get_template_tags(neu_manager_t *             manager,
     return 0;
 }
 
+static int add_template_group(neu_group_t *grp, void *data)
+{
+    neu_adapter_driver_t *driver   = data;
+    const char *          name     = neu_group_get_name(grp);
+    uint32_t              interval = neu_group_get_interval(grp);
+
+    if (interval < NEU_GROUP_INTERVAL_LIMIT) {
+        return NEU_ERR_GROUP_PARAMETER_INVALID;
+    }
+
+    int ret = neu_adapter_driver_add_group(driver, name, interval);
+    if (0 != ret) {
+        return ret;
+    }
+
+    UT_array *tags = neu_group_get_tag(grp);
+    if (NULL == tags) {
+        return NEU_ERR_EINTERNAL;
+    }
+
+    utarray_foreach(tags, neu_datatag_t *, tag)
+    {
+        ret = neu_adapter_driver_add_tag(driver, name, tag);
+        if (0 != ret) {
+            break;
+        }
+    }
+
+    utarray_free(tags);
+    return ret;
+}
+
+int neu_manager_instantiate_template(neu_manager_t *          manager,
+                                     neu_req_inst_template_t *req)
+{
+    neu_template_t *tmpl =
+        neu_template_manager_find(manager->template_manager, req->tmpl);
+    if (NULL == tmpl) {
+        return NEU_ERR_TEMPLATE_NOT_FOUND;
+    }
+
+    int ret = neu_manager_add_node(manager, req->node,
+                                   neu_template_plugin(tmpl), false);
+    if (0 != ret) {
+        return ret;
+    }
+
+    neu_adapter_t *adapter =
+        neu_node_manager_find(manager->node_manager, req->node);
+    neu_adapter_driver_t *driver = (neu_adapter_driver_t *) adapter;
+
+    if (adapter->module->type != NEU_NA_TYPE_DRIVER) {
+        ret = NEU_ERR_GROUP_NOT_ALLOW;
+        goto end;
+    }
+
+    ret = neu_template_for_each_group(tmpl, add_template_group, driver);
+
+end:
+    if (0 != ret) {
+        neu_manager_del_node(manager, req->node);
+    }
+
+    return ret;
+}
+
 UT_array *neu_manager_get_driver_group(neu_manager_t *manager)
 {
     UT_array *drivers =

src/core/manager_internal.h

@@ -76,6 +76,8 @@ int  neu_manager_del_template_tags(neu_manager_t *             manager,
 int  neu_manager_get_template_tags(neu_manager_t *             manager,
                                    neu_req_get_template_tag_t *req,
                                    UT_array **                 tags_p);
+int  neu_manager_instantiate_template(neu_manager_t *          manager,
+                                      neu_req_inst_template_t *req);
 
 UT_array *neu_manager_get_driver_group(neu_manager_t *manager);
 

src/core/storage.c

@@ -16,8 +16,10 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
+#include "errcodes.h"
 #include "utils/log.h"
 
+#include "adapter/storage.h"
 #include "storage.h"
 
 void manager_strorage_plugin(neu_manager_t *manager)
@@ -83,6 +85,45 @@ void manager_storage_unsubscribe(neu_manager_t *manager, const char *app,
     }
 }
 
+static int save_group_and_tags(neu_group_t *grp, void *data)
+{
+    const char *node     = data;
+    const char *name     = neu_group_get_name(grp);
+    uint32_t    interval = neu_group_get_interval(grp);
+
+    UT_array *tags = neu_group_get_tag(grp);
+    if (NULL == tags) {
+        return NEU_ERR_EINTERNAL;
+    }
+
+    adapter_storage_add_group(node, name, interval);
+    adapter_storage_add_tags(node, name, utarray_front(tags),
+                             utarray_len(tags));
+
+    utarray_free(tags);
+    return 0;
+}
+
+void manager_storage_inst_node(neu_manager_t *manager, const char *tmpl_name,
+                               const char *node)
+{
+    neu_template_t *tmpl =
+        neu_template_manager_find(manager->template_manager, tmpl_name);
+    if (NULL == tmpl) {
+        nlog_error("save instantiated node `%s`, fail, no template `%s`", node,
+                   tmpl_name);
+        return;
+    }
+
+    manager_storage_add_node(manager, node);
+
+    int rv =
+        neu_template_for_each_group(tmpl, save_group_and_tags, (void *) node);
+    if (0 != rv) {
+        nlog_error("save instantiated node `%s` groups and tags fail", node);
+    }
+}
+
 int manager_load_plugin(neu_manager_t *manager)
 {
     UT_array *plugin_infos = NULL;

src/core/storage.h

@@ -33,6 +33,9 @@ void manager_storage_subscribe(neu_manager_t *manager, const char *app,
 void manager_storage_unsubscribe(neu_manager_t *manager, const char *app,
                                  const char *driver, const char *group);
 
+void manager_storage_inst_node(neu_manager_t *manager, const char *tmpl_name,
+                               const char *node);
+
 int manager_load_plugin(neu_manager_t *manager);
 int manager_load_node(neu_manager_t *manager);
 int manager_load_subscribe(neu_manager_t *manager);