GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-24 02:39:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1509 from eeff/eeff/fix

Browse Source 
feat(restful): support update template group name
This commit is contained in:
fengzeroz
2023-09-06 18:20:59 +08:00
committed by GitHub
parent ffc82178a1 aaaf68ddc3
commit 639f05687b
15 changed files with 359 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ft/resource/api.resource
+3 -2
View File
@@ -258,8 +258,9 @@ Add Template Group
[RETURN] ${res}[0]
Put Template Group
[Arguments] ${tmpl} ${group} ${interval}
PUT /api/v2/template/group {"template": "${tmpl}", "group": "${group}", "interval": ${interval}}
[Arguments] ${tmpl} ${group} &{updates}
${data} = Evaluate json.dumps({"template": "${tmpl}", "group": "${group}", **$updates}) json
PUT /api/v2/template/group ${data}
${res} = Object response body
[RETURN] ${res}[0]
ft/template.robot
+96 -9
View File
@@ -496,7 +496,7 @@ Get groups from existent template having one group, it should success.
Update group interval when template does not exist, it should fail.
${res} = Put Template Group ${g_template} ${g_group1}[name] ${1000}
${res} = Put Template Group ${g_template} ${g_group1}[name] interval=${1000}
Check Response Status ${res} 404
Check Error Code ${res} ${NEU_ERR_TEMPLATE_NOT_FOUND}
@@ -508,7 +508,7 @@ Update group using too long template name in request, it should fail.
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_long_str} ${g_group1}[name] ${2000}
${res} = Put Template Group ${g_long_str} ${g_group1}[name] interval=${2000}
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_TEMPLATE_NAME_TOO_LONG}
@@ -520,7 +520,7 @@ Update group using too long group name in request, it should fail.
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_long_str} ${2000}
${res} = Put Template Group ${g_template} ${g_long_str} interval=${2000}
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_GROUP_NAME_TOO_LONG}
@@ -532,7 +532,7 @@ Update group interval when group does not exist, it should fail.
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] ${1000}
${res} = Put Template Group ${g_template} ${g_group1}[name] interval=${1000}
Check Response Status ${res} 404
Check Error Code ${res} ${NEU_ERR_GROUP_NOT_EXIST}
@@ -544,7 +544,7 @@ Update group interval to invalid value, it should fail.
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] ${10}
${res} = Put Template Group ${g_template} ${g_group1}[name] interval=${10}
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_GROUP_PARAMETER_INVALID}
@@ -556,7 +556,7 @@ Update group interval, it should success.
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] ${1000}
${res} = Put Template Group ${g_template} ${g_group1}[name] interval=${1000}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
@@ -568,6 +568,93 @@ Update group interval, it should success.
[Teardown] Del Template ${g_template}
Update group with empty new name, it should fail.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=${EMPTY}
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_BODY_IS_WRONG}
[Teardown] Del Template ${g_template}
Update group with too long new name, it should fail.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=${g_long_str}
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_GROUP_NAME_TOO_LONG}
[Teardown] Del Template ${g_template}
Update group name to conflicting group name, it should fail.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Add Template Group ${g_template} grp ${1000}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=grp
Check Response Status ${res} 409
Check Error Code ${res} ${NEU_ERR_GROUP_EXIST}
[Teardown] Del Template ${g_template}
Update group name, it should success.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=grp
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Get Template Groups ${g_template}
Check Response Status ${res} 200
Should Have Only One Group ${res}[groups] grp ${g_group1}[interval]
Group Tag Count Should Be ${res}[groups][0] 2
[Teardown] Del Template ${g_template}
Update group with at least name or interval, otherwise it should fail.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name]
Check Response Status ${res} 400
Check Error Code ${res} ${NEU_ERR_BODY_IS_WRONG}
[Teardown] Del Template ${g_template}
Update group name and interval, it should success.
${res} = Add Template ${g_template} ${g_plugin} ${g_groups}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=grp interval=${1000}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
${res} = Get Template Groups ${g_template}
Check Response Status ${res} 200
Should Have Only One Group ${res}[groups] grp ${1000}
Group Tag Count Should Be ${res}[groups][0] 2
[Teardown] Del Template ${g_template}
Delete group from nonexistent template, it should fail.
${res} = Del Template Group ${g_template} ${g_group1}[name]
Check Response Status ${res} 404
@@ -642,7 +729,7 @@ Template groups should be persisted.
Should Have Only One Group ${res}[groups] ${g_group1}[name] ${g_group1}[interval]
Group Tag Count Should Be ${res}[groups][0] 0
${res} = Put Template Group ${g_template} ${g_group1}[name] ${1000}
${res} = Put Template Group ${g_template} ${g_group1}[name] new_name=grp interval=${1000}
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
@@ -650,10 +737,10 @@ Template groups should be persisted.
${res} = Get Template Groups ${g_template}
Check Response Status ${res} 200
Should Have Only One Group ${res}[groups] ${g_group1}[name] ${1000}
Should Have Only One Group ${res}[groups] grp ${1000}
Group Tag Count Should Be ${res}[groups][0] 0
${res} = Del Template Group ${g_template} ${g_group1}[name]
${res} = Del Template Group ${g_template} grp
Check Response Status ${res} 200
Check Error Code ${res} ${NEU_ERR_SUCCESS}
include/neuron/adapter.h
+8 -1
View File
@@ -612,7 +612,14 @@ typedef struct {
char tmpl[NEU_TEMPLATE_NAME_LEN];
char group[NEU_GROUP_NAME_LEN];
uint32_t interval;
} neu_req_add_template_group_t, neu_req_update_template_group_t;
} neu_req_add_template_group_t;
typedef struct {
char tmpl[NEU_TEMPLATE_NAME_LEN];
char group[NEU_GROUP_NAME_LEN];
char new_name[NEU_GROUP_NAME_LEN];
uint32_t interval;
} neu_req_update_template_group_t;
typedef struct {
char tmpl[NEU_TEMPLATE_NAME_LEN];
include/neuron/persist/persist.h
+2
View File
@@ -383,10 +383,12 @@ int neu_persister_store_template_group(const char * tmpl_name,
/**
* Update template group.
* @param tmpl_name template name.
* @param group_name group name.
* @param group_info group info to persist.
* @return 0 on success, non-zero otherwise
*/
int neu_persister_update_template_group(const char * tmpl_name,
const char * group_name,
neu_persist_group_info_t *group_info);
/**
plugins/restful/template_handle.c
+67 -11
View File
@@ -338,8 +338,8 @@ void handle_get_templates_resp(nng_aio *aio, neu_resp_get_templates_t *resp)
}
static inline int
send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
neu_json_template_mod_group_req_t *req)
send_template_add_group_req(nng_aio * aio,
neu_json_template_add_group_req_t *req)
{
neu_plugin_t *plugin = neu_rest_get_plugin();
@@ -358,7 +358,7 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
neu_reqresp_head_t header = {
.ctx = aio,
.type = type,
.type = NEU_REQ_ADD_TEMPLATE_GROUP,
};
if (0 != neu_plugin_op(plugin, header, &cmd)) {
@@ -368,13 +368,12 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
return 0;
}
static inline void process_mod_template_group(nng_aio * aio,
neu_reqresp_type_e type)
void handle_add_template_group(nng_aio *aio)
{
NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
aio, neu_json_template_mod_group_req_t,
neu_json_decode_template_mod_group_req, {
int ret = send_template_mod_group_req(aio, type, req);
aio, neu_json_template_add_group_req_t,
neu_json_decode_template_add_group_req, {
int ret = send_template_add_group_req(aio, req);
if (ret != 0) {
NEU_JSON_RESPONSE_ERROR(
ret, { neu_http_response(aio, ret, result_error); });
@@ -382,14 +381,71 @@ static inline void process_mod_template_group(nng_aio * aio,
})
}
void handle_add_template_group(nng_aio *aio)
static inline int
send_template_update_group_req(nng_aio * aio,
neu_json_template_update_group_req_t *req)
{
process_mod_template_group(aio, NEU_REQ_ADD_TEMPLATE_GROUP);
neu_plugin_t *plugin = neu_rest_get_plugin();
if (strlen(req->tmpl) >= NEU_TEMPLATE_NAME_LEN) {
return NEU_ERR_TEMPLATE_NAME_TOO_LONG;
} else if (strlen(req->group) >= NEU_GROUP_NAME_LEN) {
return NEU_ERR_GROUP_NAME_TOO_LONG;
} else if (req->set_interval &&
(req->interval < NEU_GROUP_INTERVAL_LIMIT ||
req->interval > UINT32_MAX)) {
return NEU_ERR_GROUP_PARAMETER_INVALID;
}
// for backward compatibility,
// `new_name` or `interval` (inclusive) should be provided
if (!req->new_name && !req->set_interval) {
return NEU_ERR_BODY_IS_WRONG;
}
neu_req_update_template_group_t cmd = { 0 };
if (req->new_name) {
// if `new_name` is provided, then it should be valid
int len = strlen(req->new_name);
if (0 == len) {
return NEU_ERR_BODY_IS_WRONG;
} else if (len >= NEU_GROUP_NAME_LEN) {
return NEU_ERR_GROUP_NAME_TOO_LONG;
}
strcpy(cmd.new_name, req->new_name);
} else {
// if `new_name` is omitted, then keep the group name
strcpy(cmd.new_name, req->group);
}
strcpy(cmd.tmpl, req->tmpl);
strcpy(cmd.group, req->group);
cmd.interval = req->interval;
neu_reqresp_head_t header = {
.ctx = aio,
.type = NEU_REQ_UPDATE_TEMPLATE_GROUP,
};
if (0 != neu_plugin_op(plugin, header, &cmd)) {
return NEU_ERR_IS_BUSY;
}
return 0;
}
void handle_update_template_group(nng_aio *aio)
{
process_mod_template_group(aio, NEU_REQ_UPDATE_TEMPLATE_GROUP);
NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
aio, neu_json_template_update_group_req_t,
neu_json_decode_template_update_group_req, {
int ret = send_template_update_group_req(aio, req);
if (ret != 0) {
NEU_JSON_RESPONSE_ERROR(
ret, { neu_http_response(aio, ret, result_error); });
}
})
}
static inline int
src/adapter/storage.c
+2 -2
View File
@@ -54,8 +54,8 @@ void adapter_storage_update_group(const char *node, const char *group,
int rv = neu_persister_update_group(node, group, &info);
if (0 != rv) {
nlog_error("fail update adapter:%s group:%s, interval: %u", node, group,
interval);
nlog_error("fail update adapter:%s group:%s, new_name:%s interval: %u",
node, group, new_name, interval);
}
}
src/base/template.c
+27 -2
View File
@@ -145,8 +145,8 @@ int neu_template_del_group(neu_template_t *tmpl, const char *group)
return 0;
}
int neu_template_update_group(neu_template_t *tmpl, const char *group,
uint32_t interval)
int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
uint32_t interval)
{
group_entry_t *ent = NULL;
HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
@@ -157,6 +157,31 @@ int neu_template_update_group(neu_template_t *tmpl, const char *group,
return neu_group_update(ent->group, interval);
}
int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
const char *new_name)
{
if (0 == strcmp(group, new_name)) {
return 0;
}
if (NULL != neu_template_get_group(tmpl, new_name)) {
return NEU_ERR_GROUP_EXIST;
}
group_entry_t *ent = NULL;
HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
if (NULL == ent) {
return NEU_ERR_GROUP_NOT_EXIST;
}
HASH_DEL(tmpl->groups, ent);
int rv = neu_group_set_name(ent->group, new_name);
new_name = neu_group_get_name(ent->group);
HASH_ADD_KEYPTR(hh, tmpl->groups, new_name, strlen(new_name), ent);
return rv;
}
size_t neu_template_group_num(const neu_template_t *tmpl)
{
return HASH_COUNT(tmpl->groups);
src/base/template.h
+4 -2
View File
@@ -51,8 +51,10 @@ neu_group_t *neu_template_get_group(const neu_template_t *tmpl,
int neu_template_add_group(neu_template_t *tmpl, const char *group,
uint32_t interval);
int neu_template_del_group(neu_template_t *tmpl, const char *group);
int neu_template_update_group(neu_template_t *tmpl, const char *group,
uint32_t interval);
int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
uint32_t interval);
int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
const char *new_name);
// Iterate through groups in the template and apply `cb` each.
// NOTE: `cb` must not alter the group name or delete the group.
src/core/manager.c
+2 -6
View File
@@ -441,15 +441,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
(neu_req_update_template_group_t *) &header[1];
neu_resp_error_t e = { 0 };
if (cmd->interval < NEU_GROUP_INTERVAL_LIMIT) {
e.error = NEU_ERR_GROUP_PARAMETER_INVALID;
} else {
e.error = neu_manager_update_template_group(manager, cmd);
}
e.error = neu_manager_update_template_group(manager, cmd);
if (e.error == NEU_ERR_SUCCESS) {
manager_storage_update_template_group(cmd->tmpl, cmd->group,
cmd->interval);
cmd->new_name, cmd->interval);
}
neu_msg_exchange(header);
src/core/manager_internal.c
+15 -1
View File
@@ -332,7 +332,21 @@ int neu_manager_update_template_group(neu_manager_t * manager,
return NEU_ERR_TEMPLATE_NOT_FOUND;
}
return neu_template_update_group(tmpl, req->group, req->interval);
int rv = 0;
if (strlen(req->new_name) > 0 && 0 != strcmp(req->group, req->new_name)) {
rv = neu_template_update_group_name(tmpl, req->group, req->new_name);
if (0 != rv) {
return rv;
}
}
if (req->interval >= NEU_GROUP_INTERVAL_LIMIT) {
rv = neu_template_update_group_interval(tmpl, req->new_name,
req->interval);
}
return rv;
}
int neu_manager_del_template_group(neu_manager_t * manager,
src/core/storage.c
+7 -5
View File
@@ -234,17 +234,19 @@ void manager_storage_add_template_group(const char *tmpl, const char *group,
}
void manager_storage_update_template_group(const char *tmpl, const char *group,
uint32_t interval)
const char *new_name,
uint32_t interval)
{
neu_persist_group_info_t info = {
.name = (char *) group,
.name = (char *) new_name,
.interval = interval,
};
int rv = neu_persister_update_template_group(tmpl, &info);
int rv = neu_persister_update_template_group(tmpl, group, &info);
if (0 != rv) {
nlog_error("update template:%s grp:%s, interval:%" PRIu32 " fail", tmpl,
group, interval);
nlog_error("update template:%s group:%s, new_name:%s interval:%" PRIu32
" fail",
tmpl, group, new_name, interval);
}
}
src/core/storage.h
+2 -1
View File
@@ -55,7 +55,8 @@ void manager_storage_clear_templates(neu_manager_t *manager);
void manager_storage_add_template_group(const char *tmpl, const char *group,
uint32_t interval);
void manager_storage_update_template_group(const char *tmpl, const char *group,
uint32_t interval);
const char *new_name,
uint32_t interval);
void manager_storage_del_template_group(const char *tmpl, const char *group);
void manager_storage_add_template_tag(const char *tmpl, const char *group,
const neu_datatag_t *tag);
src/parser/neu_json_template.c
+81 -8
View File
@@ -378,10 +378,10 @@ int neu_json_encode_get_templates_resp(void *json_obj, void *param)
NEU_JSON_ELEM_SIZE(req_elems));
}
int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
int neu_json_encode_template_add_group_req(void *json_obj, void *param)
{
int ret = 0;
neu_json_template_mod_group_req_t *req = param;
neu_json_template_add_group_req_t *req = param;
neu_json_elem_t req_elems[] = { {
.name = "template",
@@ -404,12 +404,12 @@ int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
return ret;
}
int neu_json_decode_template_mod_group_req(
char *buf, neu_json_template_mod_group_req_t **result)
int neu_json_decode_template_add_group_req(
char *buf, neu_json_template_add_group_req_t **result)
{
int ret = 0;
void * json_obj = NULL;
neu_json_template_mod_group_req_t *req = NULL;
neu_json_template_add_group_req_t *req = NULL;
json_obj = neu_json_decode_new(buf);
if (NULL == json_obj) {
@@ -449,13 +449,13 @@ int neu_json_decode_template_mod_group_req(
return 0;
decode_fail:
neu_json_decode_template_mod_group_req_free(req);
neu_json_decode_template_add_group_req_free(req);
neu_json_decode_free(json_obj);
return -1;
}
void neu_json_decode_template_mod_group_req_free(
neu_json_template_mod_group_req_t *req)
void neu_json_decode_template_add_group_req_free(
neu_json_template_add_group_req_t *req)
{
if (req) {
free(req->tmpl);
@@ -464,6 +464,79 @@ void neu_json_decode_template_mod_group_req_free(
}
}
int neu_json_decode_template_update_group_req(
char *buf, neu_json_template_update_group_req_t **result)
{
int ret = 0;
neu_json_template_update_group_req_t *req = calloc(1, sizeof(*req));
if (req == NULL) {
return -1;
}
void *json_obj = neu_json_decode_new(buf);
if (NULL == json_obj) {
free(req);
return -1;
}
neu_json_elem_t req_elems[] = {
{
.name = "template",
.t = NEU_JSON_STR,
},
{
.name = "group",
.t = NEU_JSON_STR,
},
{
.name = "new_name",
.t = NEU_JSON_STR,
.attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
},
};
ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
req_elems);
req->tmpl = req_elems[0].v.val_str;
req->group = req_elems[1].v.val_str;
req->new_name = req_elems[2].v.val_str;
if (0 != ret) {
goto error;
}
json_t *json_interval = json_object_get(json_obj, "interval");
if (NULL != json_interval) {
if (!json_is_integer(json_interval)) {
nlog_error("decode interval is not integer");
goto error;
}
req->set_interval = true;
req->interval = json_integer_value(json_interval);
} else if (NULL == req->new_name) {
// at least one of `new_name` or `interval` should be provided
goto error;
}
*result = req;
neu_json_decode_free(json_obj);
return 0;
error:
neu_json_decode_template_update_group_req_free(req);
neu_json_decode_free(json_obj);
return -1;
}
void neu_json_decode_template_update_group_req_free(
neu_json_template_update_group_req_t *req)
{
free(req->tmpl);
free(req->group);
free(req->new_name);
free(req);
}
int neu_json_encode_template_del_group_req(void *json_object, void *param)
{
int ret = 0;
src/parser/neu_json_template.h
+19 -6
View File
@@ -81,13 +81,26 @@ typedef struct {
char * tmpl;
char * group;
int64_t interval;
} neu_json_template_mod_group_req_t;
} neu_json_template_add_group_req_t;
int neu_json_encode_template_mod_group_req(void *json_obj, void *param);
int neu_json_decode_template_mod_group_req(
char *buf, neu_json_template_mod_group_req_t **result);
void neu_json_decode_template_mod_group_req_free(
neu_json_template_mod_group_req_t *req);
int neu_json_encode_template_add_group_req(void *json_obj, void *param);
int neu_json_decode_template_add_group_req(
char *buf, neu_json_template_add_group_req_t **result);
void neu_json_decode_template_add_group_req_free(
neu_json_template_add_group_req_t *req);
typedef struct {
char * tmpl;
char * group;
char * new_name;
bool set_interval;
int64_t interval;
} neu_json_template_update_group_req_t;
int neu_json_decode_template_update_group_req(
char *buf, neu_json_template_update_group_req_t **result);
void neu_json_decode_template_update_group_req_free(
neu_json_template_update_group_req_t *req);
typedef struct {
char *tmpl;
src/persist/persist.c
+24 -4
View File
@@ -1487,12 +1487,32 @@ int neu_persister_store_template_group(const char * tmpl_name,
}
int neu_persister_update_template_group(const char * tmpl_name,
const char * group_name,
neu_persist_group_info_t *group_info)
{
return execute_sql(
global_db,
"UPDATE template_groups SET interval=%i WHERE tmpl_name=%Q AND name=%Q",
group_info->interval, tmpl_name, group_info->name);
int ret = -1;
bool update_name = (0 != strcmp(group_name, group_info->name));
bool update_interval = (NEU_GROUP_INTERVAL_LIMIT <= group_info->interval);
if (update_name && update_interval) {
ret = execute_sql(global_db,
"UPDATE template_groups SET name=%Q, interval=%i "
"WHERE tmpl_name=%Q AND name=%Q",
group_info->name, group_info->interval, tmpl_name,
group_name);
} else if (update_name) {
ret = execute_sql(global_db,
"UPDATE template_groups SET name=%Q "
"WHERE tmpl_name=%Q AND name=%Q",
group_info->name, tmpl_name, group_name);
} else if (update_interval) {
ret = execute_sql(global_db,
"UPDATE template_groups SET interval=%i "
"WHERE tmpl_name=%Q AND name=%Q",
group_info->interval, tmpl_name, group_name);
}
return ret;
}
int neu_persister_load_template_groups(const char *tmpl_name,