GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-17 04:40:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: start/stop group timer when driver started/stopped

Browse Source
This commit is contained in:
eeff
2024-04-25 16:36:24 +08:00
parent 6a810d616b
commit d28f4430d9
3 changed files with 89 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/adapter/adapter.c
+9 -8
View File
@@ -400,13 +400,6 @@ static int adapter_update_metric(neu_adapter_t *adapter,
return neu_node_metrics_update(adapter->metrics, group, metric_name, n);
}
static inline void adapter_reset_metrics(neu_adapter_t *adapter)
{
if (NULL != adapter->metrics) {
neu_node_metrics_reset(adapter->metrics);
}
}
static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
void *data)
{
@@ -1286,6 +1279,10 @@ int neu_adapter_start(neu_adapter_t *adapter)
if (error == NEU_ERR_SUCCESS) {
adapter->state = NEU_NODE_RUNNING_STATE_RUNNING;
adapter_storage_state(adapter->name, adapter->state);
if (NEU_NA_TYPE_DRIVER == neu_adapter_get_type(adapter)) {
neu_adapter_driver_start_group_timer(
(neu_adapter_driver_t *) adapter);
}
}
return error;
@@ -1324,7 +1321,11 @@ int neu_adapter_stop(neu_adapter_t *adapter)
if (error == NEU_ERR_SUCCESS) {
adapter->state = NEU_NODE_RUNNING_STATE_STOPPED;
adapter_storage_state(adapter->name, adapter->state);
adapter_reset_metrics(adapter);
if (NEU_NA_TYPE_DRIVER == neu_adapter_get_type(adapter)) {
neu_adapter_driver_stop_group_timer(
(neu_adapter_driver_t *) adapter);
}
neu_adapter_reset_metrics(adapter);
}
return error;
src/adapter/adapter_internal.h
+7
View File
@@ -98,6 +98,13 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter);
int neu_adapter_validate_tag(neu_adapter_t *adapter, neu_datatag_t *tag);
static inline void neu_adapter_reset_metrics(neu_adapter_t *adapter)
{
if (NULL != adapter->metrics) {
neu_node_metrics_reset(adapter->metrics);
}
}
int neu_adapter_register_group_metric(neu_adapter_t *adapter,
const char *group_name, const char *name,
const char *help, neu_metric_type_e type,
src/adapter/driver/driver.c
+73 -85
View File
@@ -103,8 +103,11 @@ static void update_with_meta(neu_adapter_t *adapter, const char *group,
const char *tag, neu_dvalue_t value,
neu_tag_meta_t *metas, int n_meta);
static void write_response(neu_adapter_t *adapter, void *r, neu_error error);
static group_t *find_group(neu_adapter_driver_t *driver, const char *name);
static void store_write_tag(group_t *group, to_be_write_tag_t *tag);
static group_t * find_group(neu_adapter_driver_t *driver, const char *name);
static void store_write_tag(group_t *group, to_be_write_tag_t *tag);
static inline void start_group_timer(neu_adapter_driver_t *driver,
group_t * grp);
static inline void stop_group_timer(neu_adapter_driver_t *driver, group_t *grp);
static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
{
@@ -324,9 +327,7 @@ int neu_adapter_driver_uninit(neu_adapter_driver_t *driver)
HASH_DEL(driver->groups, el);
neu_adapter_driver_try_del_tag(driver, neu_group_tag_size(el->group));
neu_adapter_del_timer((neu_adapter_t *) driver, el->report);
neu_event_del_timer(driver->driver_events, el->read);
neu_event_del_timer(driver->driver_events, el->write);
stop_group_timer(driver, el);
if (el->grp.group_free != NULL) {
el->grp.group_free(&el->grp);
}
@@ -349,34 +350,67 @@ int neu_adapter_driver_uninit(neu_adapter_driver_t *driver)
return 0;
}
static inline void start_group_timer(neu_adapter_driver_t *driver, group_t *grp)
{
uint32_t interval = neu_group_get_interval(grp->group);
neu_event_timer_param_t param = {
.second = interval / 1000,
.millisecond = interval % 1000,
.usr_data = (void *) grp,
.type = NEU_EVENT_TIMER_NOBLOCK,
};
param.type = driver->adapter.module->timer_type;
param.cb = read_callback;
grp->read = neu_event_add_timer(driver->driver_events, param);
struct timespec t1 = {
.tv_sec = 0,
.tv_nsec = 1000 * 1000 * 20,
};
struct timespec t2 = { 0 };
nanosleep(&t1, &t2);
param.type = NEU_EVENT_TIMER_NOBLOCK;
param.cb = report_callback;
grp->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
param.second = 0;
param.millisecond = 3;
param.cb = write_callback;
grp->write = neu_event_add_timer(driver->driver_events, param);
}
void neu_adapter_driver_start_group_timer(neu_adapter_driver_t *driver)
{
group_t *el = NULL, *tmp = NULL;
HASH_ITER(hh, driver->groups, el, tmp)
{
uint32_t interval = neu_group_get_interval(el->group);
neu_event_timer_param_t param = {
.second = interval / 1000,
.millisecond = interval % 1000,
.usr_data = el,
.type = NEU_EVENT_TIMER_NOBLOCK,
};
start_group_timer(driver, el);
neu_adapter_update_group_metric(
&driver->adapter, neu_group_get_name(el->group),
NEU_METRIC_GROUP_TAGS_TOTAL, neu_group_tag_size(el->group));
}
param.type = driver->adapter.module->timer_type;
param.cb = read_callback;
el->read = neu_event_add_timer(driver->driver_events, param);
driver->adapter.cb_funs.update_metric(
&driver->adapter, NEU_METRIC_TAGS_TOTAL, driver->tag_cnt, NULL);
}
struct timespec t1 = {
.tv_sec = 0,
.tv_nsec = 1000 * 1000 * 20,
};
struct timespec t2 = { 0 };
nanosleep(&t1, &t2);
param.type = NEU_EVENT_TIMER_NOBLOCK;
param.cb = report_callback;
el->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
static inline void stop_group_timer(neu_adapter_driver_t *driver, group_t *grp)
{
if (grp->report) {
neu_adapter_del_timer((neu_adapter_t *) driver, grp->report);
grp->report = NULL;
}
if (grp->read) {
neu_event_del_timer(driver->driver_events, grp->read);
grp->read = NULL;
}
if (grp->write) {
neu_event_del_timer(driver->driver_events, grp->write);
grp->write = NULL;
}
}
@@ -384,13 +418,7 @@ void neu_adapter_driver_stop_group_timer(neu_adapter_driver_t *driver)
{
group_t *el = NULL, *tmp = NULL;
HASH_ITER(hh, driver->groups, el, tmp)
{
neu_adapter_del_timer((neu_adapter_t *) driver, el->report);
el->report = NULL;
neu_event_del_timer(driver->driver_events, el->read);
el->read = NULL;
}
HASH_ITER(hh, driver->groups, el, tmp) { stop_group_timer(driver, el); }
}
void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
@@ -887,13 +915,6 @@ int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
if (find == NULL) {
find = calloc(1, sizeof(group_t));
neu_event_timer_param_t param = {
.second = interval / 1000,
.millisecond = interval % 1000,
.usr_data = (void *) find,
.type = NEU_EVENT_TIMER_NOBLOCK,
};
pthread_mutex_init(&find->wt_mtx, NULL);
pthread_mutex_init(&find->apps_mtx, NULL);
@@ -907,25 +928,9 @@ int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
neu_group_split_static_tags(find->group, &find->static_tags,
&find->grp.tags);
param.type = driver->adapter.module->timer_type;
param.cb = read_callback;
find->read = neu_event_add_timer(driver->driver_events, param);
struct timespec t1 = {
.tv_sec = 0,
.tv_nsec = 1000 * 1000 * 20,
};
struct timespec t2 = { 0 };
nanosleep(&t1, &t2);
param.type = NEU_EVENT_TIMER_NOBLOCK;
param.cb = report_callback;
find->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
param.second = 0;
param.millisecond = 3;
param.cb = write_callback;
find->write = neu_event_add_timer(driver->driver_events, param);
if (NEU_NODE_RUNNING_STATE_RUNNING == driver->adapter.state) {
start_group_timer(driver, find);
}
REGISTER_GROUP_METRIC(&driver->adapter, find->name,
NEU_METRIC_GROUP_TAGS_TOTAL,
@@ -972,8 +977,9 @@ int neu_adapter_driver_update_group(neu_adapter_driver_t *driver,
}
// stop the timer first to avoid race condition
neu_adapter_del_timer((neu_adapter_t *) driver, find->report);
neu_event_del_timer(driver->driver_events, find->read);
if (NEU_NODE_RUNNING_STATE_RUNNING == driver->adapter.state) {
stop_group_timer(driver, find);
}
// a diminutive value should keep the interval untouched
if (interval < NEU_GROUP_INTERVAL_LIMIT) {
@@ -1002,31 +1008,12 @@ int neu_adapter_driver_update_group(neu_adapter_driver_t *driver,
}
}
neu_event_timer_param_t param = {
.second = interval / 1000,
.millisecond = interval % 1000,
.usr_data = (void *) find,
.type = NEU_EVENT_TIMER_NOBLOCK,
};
neu_group_set_interval(find->group, interval);
// restore the timers
param.type = driver->adapter.module->timer_type;
param.cb = read_callback;
find->read = neu_event_add_timer(driver->driver_events, param);
struct timespec t1 = {
.tv_sec = 0,
.tv_nsec = 1000 * 1000 * 20,
};
struct timespec t2 = { 0 };
nanosleep(&t1, &t2);
param.type = NEU_EVENT_TIMER_NOBLOCK;
param.cb = report_callback;
find->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
if (NEU_NODE_RUNNING_STATE_RUNNING == driver->adapter.state) {
start_group_timer(driver, find);
}
return ret;
}
@@ -1042,9 +1029,10 @@ int neu_adapter_driver_del_group(neu_adapter_driver_t *driver, const char *name)
neu_adapter_driver_try_del_tag(driver, neu_group_tag_size(find->group));
neu_adapter_del_timer((neu_adapter_t *) driver, find->report);
neu_event_del_timer(driver->driver_events, find->read);
neu_event_del_timer(driver->driver_events, find->write);
if (NEU_NODE_RUNNING_STATE_RUNNING == driver->adapter.state) {
stop_group_timer(driver, find);
}
if (find->grp.group_free != NULL) {
find->grp.group_free(&find->grp);
}