/* ** Zabbix ** Copyright (C) 2001-2021 Zabbix SIA ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program; if not, write to the Free Software ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. **/ #include "lld.h" #include "db.h" #include "log.h" #include "zbxalgo.h" #include "zbxserver.h" typedef struct { zbx_uint64_t triggerid; char *description; char *expression; char *recovery_expression; char *comments; char *url; char *correlation_tag; char *opdata; unsigned char status; unsigned char type; unsigned char priority; unsigned char recovery_mode; unsigned char correlation_mode; unsigned char manual_close; unsigned char discover; zbx_vector_ptr_t functions; zbx_vector_ptr_t dependencies; zbx_vector_ptr_t tags; } zbx_lld_trigger_prototype_t; typedef struct { zbx_uint64_t triggerid; zbx_uint64_t parent_triggerid; char *description; char *description_orig; char *expression; char *expression_orig; char *recovery_expression; char *recovery_expression_orig; char *comments; char *comments_orig; char *url; char *url_orig; char *correlation_tag; char *correlation_tag_orig; char *opdata; char *opdata_orig; zbx_vector_ptr_t functions; zbx_vector_ptr_t dependencies; zbx_vector_ptr_t dependents; zbx_vector_ptr_t tags; zbx_vector_ptr_pair_t override_tags; #define ZBX_FLAG_LLD_TRIGGER_UNSET __UINT64_C(0x0000) #define ZBX_FLAG_LLD_TRIGGER_DISCOVERED __UINT64_C(0x0001) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION __UINT64_C(0x0002) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION __UINT64_C(0x0004) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_TYPE __UINT64_C(0x0008) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_PRIORITY __UINT64_C(0x0010) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_COMMENTS __UINT64_C(0x0020) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_URL __UINT64_C(0x0040) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION __UINT64_C(0x0080) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_MODE __UINT64_C(0x0100) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_MODE __UINT64_C(0x0200) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_TAG __UINT64_C(0x0400) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_MANUAL_CLOSE __UINT64_C(0x0800) #define ZBX_FLAG_LLD_TRIGGER_UPDATE_OPDATA __UINT64_C(0x1000) #define ZBX_FLAG_LLD_TRIGGER_UPDATE \ (ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION | ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION | \ ZBX_FLAG_LLD_TRIGGER_UPDATE_TYPE | ZBX_FLAG_LLD_TRIGGER_UPDATE_PRIORITY | \ ZBX_FLAG_LLD_TRIGGER_UPDATE_COMMENTS | ZBX_FLAG_LLD_TRIGGER_UPDATE_URL | \ ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION | ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_MODE | \ ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_MODE | ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_TAG | \ ZBX_FLAG_LLD_TRIGGER_UPDATE_MANUAL_CLOSE | ZBX_FLAG_LLD_TRIGGER_UPDATE_OPDATA) zbx_uint64_t flags; int lastcheck; int ts_delete; unsigned char status; unsigned char priority; } zbx_lld_trigger_t; typedef struct { zbx_uint64_t functionid; zbx_uint64_t index; zbx_uint64_t itemid; zbx_uint64_t itemid_orig; char *function; char *function_orig; char *parameter; char *parameter_orig; #define ZBX_FLAG_LLD_FUNCTION_UNSET __UINT64_C(0x00) #define ZBX_FLAG_LLD_FUNCTION_DISCOVERED __UINT64_C(0x01) #define ZBX_FLAG_LLD_FUNCTION_UPDATE_ITEMID __UINT64_C(0x02) #define ZBX_FLAG_LLD_FUNCTION_UPDATE_FUNCTION __UINT64_C(0x04) #define ZBX_FLAG_LLD_FUNCTION_UPDATE_PARAMETER __UINT64_C(0x08) #define ZBX_FLAG_LLD_FUNCTION_UPDATE \ (ZBX_FLAG_LLD_FUNCTION_UPDATE_ITEMID | ZBX_FLAG_LLD_FUNCTION_UPDATE_FUNCTION | \ ZBX_FLAG_LLD_FUNCTION_UPDATE_PARAMETER) #define ZBX_FLAG_LLD_FUNCTION_DELETE __UINT64_C(0x10) zbx_uint64_t flags; } zbx_lld_function_t; typedef struct { zbx_uint64_t triggerdepid; zbx_uint64_t triggerid_up; /* generic trigger */ zbx_lld_trigger_t *trigger_up; /* lld-created trigger; (null) if trigger depends on generic trigger */ #define ZBX_FLAG_LLD_DEPENDENCY_UNSET __UINT64_C(0x00) #define ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED __UINT64_C(0x01) #define ZBX_FLAG_LLD_DEPENDENCY_DELETE __UINT64_C(0x02) zbx_uint64_t flags; } zbx_lld_dependency_t; typedef struct { zbx_uint64_t triggertagid; char *tag; char *value; #define ZBX_FLAG_LLD_TAG_UNSET __UINT64_C(0x00) #define ZBX_FLAG_LLD_TAG_DISCOVERED __UINT64_C(0x01) #define ZBX_FLAG_LLD_TAG_UPDATE_TAG __UINT64_C(0x02) #define ZBX_FLAG_LLD_TAG_UPDATE_VALUE __UINT64_C(0x04) #define ZBX_FLAG_LLD_TAG_UPDATE \ (ZBX_FLAG_LLD_TAG_UPDATE_TAG | ZBX_FLAG_LLD_TAG_UPDATE_VALUE) #define ZBX_FLAG_LLD_TAG_DELETE __UINT64_C(0x08) zbx_uint64_t flags; } zbx_lld_tag_t; typedef struct { zbx_uint64_t parent_triggerid; zbx_uint64_t itemid; zbx_lld_trigger_t *trigger; } zbx_lld_item_trigger_t; typedef struct { zbx_uint64_t itemid; unsigned char flags; } zbx_lld_item_t; /* a reference to trigger which could be either existing trigger in database or */ /* a just discovered trigger stored in memory */ typedef struct { /* trigger id, 0 for newly discovered triggers */ zbx_uint64_t triggerid; /* trigger data, NULL for non-discovered triggers */ zbx_lld_trigger_t *trigger; /* flags to mark trigger dependencies during trigger dependency validation */ #define ZBX_LLD_TRIGGER_DEPENDENCY_NORMAL 0 #define ZBX_LLD_TRIGGER_DEPENDENCY_NEW 1 #define ZBX_LLD_TRIGGER_DEPENDENCY_DELETE 2 /* flags used to mark dependencies when trigger reference is use to store dependency links */ int flags; } zbx_lld_trigger_ref_t; /* a trigger node used to build trigger tree for dependency validation */ typedef struct { /* trigger reference */ zbx_lld_trigger_ref_t trigger_ref; /* the current iteration number, used during dependency validation */ int iter_num; /* the number of dependents */ int parents; /* trigger dependency list */ zbx_vector_ptr_t dependencies; } zbx_lld_trigger_node_t; /* a structure to keep information about current iteration during trigger dependencies validation */ typedef struct { /* iteration number */ int iter_num; /* the dependency (from->to) that should be removed in the case of recursive loop */ zbx_lld_trigger_ref_t *ref_from; zbx_lld_trigger_ref_t *ref_to; } zbx_lld_trigger_node_iter_t; static void lld_tag_free(zbx_lld_tag_t *tag) { zbx_free(tag->tag); zbx_free(tag->value); zbx_free(tag); } static void lld_item_free(zbx_lld_item_t *item) { zbx_free(item); } static void lld_function_free(zbx_lld_function_t *function) { zbx_free(function->parameter_orig); zbx_free(function->parameter); zbx_free(function->function_orig); zbx_free(function->function); zbx_free(function); } static void lld_trigger_prototype_free(zbx_lld_trigger_prototype_t *trigger_prototype) { zbx_vector_ptr_clear_ext(&trigger_prototype->tags, (zbx_clean_func_t)lld_tag_free); zbx_vector_ptr_destroy(&trigger_prototype->tags); zbx_vector_ptr_clear_ext(&trigger_prototype->dependencies, zbx_ptr_free); zbx_vector_ptr_destroy(&trigger_prototype->dependencies); zbx_vector_ptr_clear_ext(&trigger_prototype->functions, (zbx_mem_free_func_t)lld_function_free); zbx_vector_ptr_destroy(&trigger_prototype->functions); zbx_free(trigger_prototype->opdata); zbx_free(trigger_prototype->correlation_tag); zbx_free(trigger_prototype->url); zbx_free(trigger_prototype->comments); zbx_free(trigger_prototype->recovery_expression); zbx_free(trigger_prototype->expression); zbx_free(trigger_prototype->description); zbx_free(trigger_prototype); } static void lld_trigger_free(zbx_lld_trigger_t *trigger) { zbx_vector_ptr_clear_ext(&trigger->tags, (zbx_clean_func_t)lld_tag_free); zbx_vector_ptr_pair_destroy(&trigger->override_tags); zbx_vector_ptr_destroy(&trigger->tags); zbx_vector_ptr_destroy(&trigger->dependents); zbx_vector_ptr_clear_ext(&trigger->dependencies, zbx_ptr_free); zbx_vector_ptr_destroy(&trigger->dependencies); zbx_vector_ptr_clear_ext(&trigger->functions, (zbx_clean_func_t)lld_function_free); zbx_vector_ptr_destroy(&trigger->functions); zbx_free(trigger->opdata_orig); zbx_free(trigger->opdata); zbx_free(trigger->correlation_tag_orig); zbx_free(trigger->correlation_tag); zbx_free(trigger->url_orig); zbx_free(trigger->url); zbx_free(trigger->comments_orig); zbx_free(trigger->comments); zbx_free(trigger->recovery_expression_orig); zbx_free(trigger->recovery_expression); zbx_free(trigger->expression_orig); zbx_free(trigger->expression); zbx_free(trigger->description_orig); zbx_free(trigger->description); zbx_free(trigger); } /****************************************************************************** * * * Function: lld_trigger_prototypes_get * * * * Purpose: retrieve trigger prototypes which are inherited from the * * discovery rule * * * * Parameters: lld_ruleid - [IN] discovery rule id * * trigger_prototypes - [OUT] sorted list of trigger prototypes * * * ******************************************************************************/ static void lld_trigger_prototypes_get(zbx_uint64_t lld_ruleid, zbx_vector_ptr_t *trigger_prototypes) { DB_RESULT result; DB_ROW row; zbx_lld_trigger_prototype_t *trigger_prototype; result = DBselect( "select distinct t.triggerid,t.description,t.expression,t.status,t.type,t.priority,t.comments," "t.url,t.recovery_expression,t.recovery_mode,t.correlation_mode,t.correlation_tag," "t.manual_close,t.opdata,t.discover" " from triggers t,functions f,items i,item_discovery id" " where t.triggerid=f.triggerid" " and f.itemid=i.itemid" " and i.itemid=id.itemid" " and id.parent_itemid=" ZBX_FS_UI64, lld_ruleid); /* run through trigger prototypes */ while (NULL != (row = DBfetch(result))) { trigger_prototype = (zbx_lld_trigger_prototype_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_prototype_t)); ZBX_STR2UINT64(trigger_prototype->triggerid, row[0]); trigger_prototype->description = zbx_strdup(NULL, row[1]); trigger_prototype->expression = zbx_strdup(NULL, row[2]); trigger_prototype->recovery_expression = zbx_strdup(NULL, row[8]); ZBX_STR2UCHAR(trigger_prototype->status, row[3]); ZBX_STR2UCHAR(trigger_prototype->type, row[4]); ZBX_STR2UCHAR(trigger_prototype->priority, row[5]); ZBX_STR2UCHAR(trigger_prototype->recovery_mode, row[9]); trigger_prototype->comments = zbx_strdup(NULL, row[6]); trigger_prototype->url = zbx_strdup(NULL, row[7]); ZBX_STR2UCHAR(trigger_prototype->correlation_mode, row[10]); trigger_prototype->correlation_tag = zbx_strdup(NULL, row[11]); ZBX_STR2UCHAR(trigger_prototype->manual_close, row[12]); trigger_prototype->opdata = zbx_strdup(NULL, row[13]); ZBX_STR2UCHAR(trigger_prototype->discover, row[14]); zbx_vector_ptr_create(&trigger_prototype->functions); zbx_vector_ptr_create(&trigger_prototype->dependencies); zbx_vector_ptr_create(&trigger_prototype->tags); zbx_vector_ptr_append(trigger_prototypes, trigger_prototype); } DBfree_result(result); zbx_vector_ptr_sort(trigger_prototypes, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } /****************************************************************************** * * * Function: lld_triggers_get * * * * Purpose: retrieve triggers which were created by the specified trigger * * prototypes * * * * Parameters: trigger_prototypes - [IN] sorted list of trigger prototypes * * triggers - [OUT] sorted list of triggers * * * ******************************************************************************/ static void lld_triggers_get(const zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers) { DB_RESULT result; DB_ROW row; zbx_vector_uint64_t parent_triggerids; char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; int i; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_uint64_create(&parent_triggerids); zbx_vector_uint64_reserve(&parent_triggerids, trigger_prototypes->values_num); for (i = 0; i < trigger_prototypes->values_num; i++) { const zbx_lld_trigger_prototype_t *trigger_prototype; trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&parent_triggerids, trigger_prototype->triggerid); } sql = (char *)zbx_malloc(sql, sql_alloc); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select td.parent_triggerid,t.triggerid,t.description,t.expression,t.type,t.priority," "t.comments,t.url,t.recovery_expression,t.recovery_mode,t.correlation_mode," "t.correlation_tag,t.manual_close,t.opdata,td.lastcheck,td.ts_delete" " from triggers t,trigger_discovery td" " where t.triggerid=td.triggerid" " and"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "td.parent_triggerid", parent_triggerids.values, parent_triggerids.values_num); zbx_vector_uint64_destroy(&parent_triggerids); result = DBselect("%s", sql); zbx_free(sql); while (NULL != (row = DBfetch(result))) { zbx_uint64_t parent_triggerid; const zbx_lld_trigger_prototype_t *trigger_prototype; zbx_lld_trigger_t *trigger; int index; ZBX_STR2UINT64(parent_triggerid, row[0]); if (FAIL == (index = zbx_vector_ptr_bsearch(trigger_prototypes, &parent_triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { THIS_SHOULD_NEVER_HAPPEN; continue; } trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; trigger = (zbx_lld_trigger_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_t)); ZBX_STR2UINT64(trigger->triggerid, row[1]); trigger->parent_triggerid = parent_triggerid; trigger->description = zbx_strdup(NULL, row[2]); trigger->description_orig = NULL; trigger->expression = zbx_strdup(NULL, row[3]); trigger->expression_orig = NULL; trigger->recovery_expression = zbx_strdup(NULL, row[8]); trigger->recovery_expression_orig = NULL; trigger->flags = ZBX_FLAG_LLD_TRIGGER_UNSET; if ((unsigned char)atoi(row[4]) != trigger_prototype->type) trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_TYPE; trigger->priority = (unsigned char)atoi(row[5]); if ((unsigned char)atoi(row[9]) != trigger_prototype->recovery_mode) trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_MODE; if ((unsigned char)atoi(row[10]) != trigger_prototype->correlation_mode) trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_MODE; if ((unsigned char)atoi(row[12]) != trigger_prototype->manual_close) trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_MANUAL_CLOSE; trigger->comments = zbx_strdup(NULL, row[6]); trigger->comments_orig = NULL; trigger->url = zbx_strdup(NULL, row[7]); trigger->url_orig = NULL; trigger->correlation_tag = zbx_strdup(NULL, row[11]); trigger->correlation_tag_orig = NULL; trigger->opdata = zbx_strdup(NULL, row[13]); trigger->opdata_orig = NULL; trigger->lastcheck = atoi(row[14]); trigger->ts_delete = atoi(row[15]); zbx_vector_ptr_create(&trigger->functions); zbx_vector_ptr_create(&trigger->dependencies); zbx_vector_ptr_create(&trigger->dependents); zbx_vector_ptr_create(&trigger->tags); zbx_vector_ptr_pair_create(&trigger->override_tags); zbx_vector_ptr_append(triggers, trigger); } DBfree_result(result); zbx_vector_ptr_sort(triggers, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_functions_get * * * * Purpose: retrieve functions which are used by all triggers in the host of * * the trigger prototype * * * ******************************************************************************/ static void lld_functions_get(zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers) { int i; zbx_lld_trigger_prototype_t *trigger_prototype; zbx_lld_trigger_t *trigger; zbx_vector_uint64_t triggerids; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_uint64_create(&triggerids); if (NULL != trigger_prototypes) { for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&triggerids, trigger_prototype->triggerid); } } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_uint64_append(&triggerids, trigger->triggerid); } if (0 != triggerids.values_num) { DB_RESULT result; DB_ROW row; zbx_lld_function_t *function; zbx_uint64_t triggerid; char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; int index; zbx_vector_uint64_sort(&triggerids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); sql = (char *)zbx_malloc(sql, sql_alloc); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select functionid,triggerid,itemid,name,parameter" " from functions" " where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "triggerid", triggerids.values, triggerids.values_num); result = DBselect("%s", sql); zbx_free(sql); while (NULL != (row = DBfetch(result))) { function = (zbx_lld_function_t *)zbx_malloc(NULL, sizeof(zbx_lld_function_t)); function->index = 0; ZBX_STR2UINT64(function->functionid, row[0]); ZBX_STR2UINT64(triggerid, row[1]); ZBX_STR2UINT64(function->itemid, row[2]); function->itemid_orig = 0; function->function = zbx_strdup(NULL, row[3]); function->function_orig = NULL; function->parameter = zbx_strdup(NULL, row[4]); function->parameter_orig = NULL; function->flags = ZBX_FLAG_LLD_FUNCTION_UNSET; if (NULL != trigger_prototypes && FAIL != (index = zbx_vector_ptr_bsearch(trigger_prototypes, &triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; zbx_vector_ptr_append(&trigger_prototype->functions, function); } else if (FAIL != (index = zbx_vector_ptr_bsearch(triggers, &triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger = (zbx_lld_trigger_t *)triggers->values[index]; zbx_vector_ptr_append(&trigger->functions, function); } else { THIS_SHOULD_NEVER_HAPPEN; lld_function_free(function); } } DBfree_result(result); if (NULL != trigger_prototypes) { for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_ptr_sort(&trigger_prototype->functions, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_ptr_sort(&trigger->functions, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } } zbx_vector_uint64_destroy(&triggerids); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_dependencies_get * * * * Purpose: retrieve trigger dependencies * * * ******************************************************************************/ static void lld_dependencies_get(zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers) { DB_RESULT result; DB_ROW row; zbx_lld_trigger_prototype_t *trigger_prototype; zbx_lld_trigger_t *trigger; zbx_lld_dependency_t *dependency; zbx_vector_uint64_t triggerids; zbx_uint64_t triggerid_down; char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; int i, index; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_uint64_create(&triggerids); for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&triggerids, trigger_prototype->triggerid); } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_uint64_append(&triggerids, trigger->triggerid); } zbx_vector_uint64_sort(&triggerids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); sql = (char *)zbx_malloc(sql, sql_alloc); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select triggerdepid,triggerid_down,triggerid_up" " from trigger_depends" " where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "triggerid_down", triggerids.values, triggerids.values_num); zbx_vector_uint64_destroy(&triggerids); result = DBselect("%s", sql); zbx_free(sql); while (NULL != (row = DBfetch(result))) { dependency = (zbx_lld_dependency_t *)zbx_malloc(NULL, sizeof(zbx_lld_dependency_t)); ZBX_STR2UINT64(dependency->triggerdepid, row[0]); ZBX_STR2UINT64(triggerid_down, row[1]); ZBX_STR2UINT64(dependency->triggerid_up, row[2]); dependency->trigger_up = NULL; dependency->flags = ZBX_FLAG_LLD_DEPENDENCY_UNSET; if (FAIL != (index = zbx_vector_ptr_bsearch(trigger_prototypes, &triggerid_down, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; zbx_vector_ptr_append(&trigger_prototype->dependencies, dependency); } else if (FAIL != (index = zbx_vector_ptr_bsearch(triggers, &triggerid_down, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger = (zbx_lld_trigger_t *)triggers->values[index]; zbx_vector_ptr_append(&trigger->dependencies, dependency); } else { THIS_SHOULD_NEVER_HAPPEN; zbx_ptr_free(dependency); } } DBfree_result(result); for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_ptr_sort(&trigger_prototype->dependencies, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_ptr_sort(&trigger->dependencies, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_tags_get * * * * Purpose: retrieve trigger tags * * * ******************************************************************************/ static void lld_tags_get(zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers) { DB_RESULT result; DB_ROW row; zbx_vector_uint64_t triggerids; int i, index; zbx_lld_trigger_prototype_t *trigger_prototype; zbx_lld_trigger_t *trigger; zbx_lld_tag_t *tag; char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; zbx_uint64_t triggerid; zbx_vector_uint64_create(&triggerids); for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&triggerids, trigger_prototype->triggerid); } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_uint64_append(&triggerids, trigger->triggerid); } zbx_vector_uint64_sort(&triggerids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); sql = (char *)zbx_malloc(sql, sql_alloc); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select triggertagid,triggerid,tag,value" " from trigger_tag" " where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "triggerid", triggerids.values, triggerids.values_num); zbx_vector_uint64_destroy(&triggerids); result = DBselect("%s", sql); zbx_free(sql); while (NULL != (row = DBfetch(result))) { tag = (zbx_lld_tag_t *)zbx_malloc(NULL, sizeof(zbx_lld_tag_t)); ZBX_STR2UINT64(tag->triggertagid, row[0]); ZBX_STR2UINT64(triggerid, row[1]); tag->tag = zbx_strdup(NULL, row[2]); tag->value = zbx_strdup(NULL, row[3]); tag->flags = ZBX_FLAG_LLD_DEPENDENCY_UNSET; if (FAIL != (index = zbx_vector_ptr_bsearch(trigger_prototypes, &triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; zbx_vector_ptr_append(&trigger_prototype->tags, tag); } else if (FAIL != (index = zbx_vector_ptr_bsearch(triggers, &triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { trigger = (zbx_lld_trigger_t *)triggers->values[index]; zbx_vector_ptr_append(&trigger->tags, tag); } else { THIS_SHOULD_NEVER_HAPPEN; zbx_ptr_free(tag); } } DBfree_result(result); for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_ptr_sort(&trigger_prototype->tags, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; zbx_vector_ptr_sort(&trigger->tags, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_items_get * * * * Purpose: returns the list of items which are related to the trigger * * prototypes * * * * Parameters: trigger_prototypes - [IN] a vector of trigger prototypes * * items - [OUT] sorted list of items * * * ******************************************************************************/ static void lld_items_get(zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *items) { DB_RESULT result; DB_ROW row; zbx_lld_item_t *item; zbx_vector_uint64_t parent_triggerids; char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; int i; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_uint64_create(&parent_triggerids); zbx_vector_uint64_reserve(&parent_triggerids, trigger_prototypes->values_num); for (i = 0; i < trigger_prototypes->values_num; i++) { zbx_lld_trigger_prototype_t *trigger_prototype; trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&parent_triggerids, trigger_prototype->triggerid); } sql = (char *)zbx_malloc(sql, sql_alloc); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select distinct i.itemid,i.flags" " from items i,functions f" " where i.itemid=f.itemid" " and"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "f.triggerid", parent_triggerids.values, parent_triggerids.values_num); zbx_vector_uint64_destroy(&parent_triggerids); result = DBselect("%s", sql); zbx_free(sql); while (NULL != (row = DBfetch(result))) { item = (zbx_lld_item_t *)zbx_malloc(NULL, sizeof(zbx_lld_item_t)); ZBX_STR2UINT64(item->itemid, row[0]); ZBX_STR2UCHAR(item->flags, row[1]); zbx_vector_ptr_append(items, item); } DBfree_result(result); zbx_vector_ptr_sort(items, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_trigger_get * * * * Purpose: finds already existing trigger, using an item prototype and items * * already created by it * * * * Return value: upon successful completion return pointer to the trigger * * * ******************************************************************************/ static zbx_lld_trigger_t *lld_trigger_get(zbx_uint64_t parent_triggerid, zbx_hashset_t *items_triggers, const zbx_vector_ptr_t *item_links) { int i; for (i = 0; i < item_links->values_num; i++) { zbx_lld_item_trigger_t *item_trigger, item_trigger_local; const zbx_lld_item_link_t *item_link = (zbx_lld_item_link_t *)item_links->values[i]; item_trigger_local.parent_triggerid = parent_triggerid; item_trigger_local.itemid = item_link->itemid; if (NULL != (item_trigger = (zbx_lld_item_trigger_t *)zbx_hashset_search(items_triggers, &item_trigger_local))) return item_trigger->trigger; } return NULL; } static void lld_expression_simplify(char **expression, zbx_vector_ptr_t *functions, zbx_uint64_t *function_index) { size_t l, r; int index; zbx_uint64_t functionid; zbx_lld_function_t *function; char buffer[ZBX_MAX_UINT64_LEN]; for (l = 0; '\0' != (*expression)[l]; l++) { if ('{' != (*expression)[l]) continue; if ('$' == (*expression)[l + 1]) { int macro_r, context_l, context_r; if (SUCCEED == zbx_user_macro_parse(*expression + l, ¯o_r, &context_l, &context_r, NULL)) l += macro_r; else l++; continue; } for (r = l + 1; '\0' != (*expression)[r] && '}' != (*expression)[r]; r++) ; if ('}' != (*expression)[r]) continue; /* ... > 0 | {12345} + ... */ /* l r */ if (SUCCEED != is_uint64_n(*expression + l + 1, r - l - 1, &functionid)) continue; if (FAIL != (index = zbx_vector_ptr_bsearch(functions, &functionid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC))) { function = (zbx_lld_function_t *)functions->values[index]; if (0 == function->index) function->index = ++(*function_index); zbx_snprintf(buffer, sizeof(buffer), ZBX_FS_UI64, function->index); r--; zbx_replace_string(expression, l + 1, &r, buffer); r++; } l = r; } } static void lld_expressions_simplify(char **expression, char **recovery_expression, zbx_vector_ptr_t *functions) { zbx_uint64_t function_index = 0; zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s' recovery_expression:'%s'", __func__, *expression, *recovery_expression); lld_expression_simplify(expression, functions, &function_index); lld_expression_simplify(recovery_expression, functions, &function_index); zabbix_log(LOG_LEVEL_DEBUG, "End of %s() expression:'%s' recovery_expression:'%s'", __func__, *expression, *recovery_expression); } static char *lld_expression_expand(const char *expression, const zbx_vector_ptr_t *functions) { size_t l, r; int i; zbx_uint64_t index; char *buffer = NULL; size_t buffer_alloc = 64, buffer_offset = 0; zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __func__, expression); buffer = (char *)zbx_malloc(buffer, buffer_alloc); *buffer = '\0'; for (l = 0; '\0' != expression[l]; l++) { zbx_chrcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, expression[l]); if ('{' != expression[l]) continue; if ('$' == expression[l + 1]) { int macro_r, context_l, context_r; if (SUCCEED == zbx_user_macro_parse(expression + l, ¯o_r, &context_l, &context_r, NULL)) l += macro_r; else l++; continue; } for (r = l + 1; '\0' != expression[r] && '}' != expression[r]; r++) ; if ('}' != expression[r]) continue; /* ... > 0 | {1} + ... */ /* l r */ if (SUCCEED != is_uint64_n(expression + l + 1, r - l - 1, &index)) continue; for (i = 0; i < functions->values_num; i++) { const zbx_lld_function_t *function = (zbx_lld_function_t *)functions->values[i]; if (function->index != index) continue; zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset, ZBX_FS_UI64 ":%s(%s)", function->itemid, function->function, function->parameter); break; } l = r - 1; } zabbix_log(LOG_LEVEL_DEBUG, "End of %s():'%s'", __func__, buffer); return buffer; } static int lld_parameter_make(const char *e, char **exp, const struct zbx_json_parse *jp_row, const zbx_vector_ptr_t *lld_macros, char **error) { int ret; size_t exp_alloc = 0, exp_offset = 0; size_t length; char err[64]; if (FAIL == zbx_function_validate_parameters(e, &length)) { *error = zbx_dsprintf(*error, "Invalid parameter \"%s\"", e); return FAIL; } if (FAIL == (ret = substitute_function_lld_param(e, length, 0, exp, &exp_alloc, &exp_offset, jp_row, lld_macros, err, sizeof(err)))) { *error = zbx_strdup(*error, err); } return ret; } static int lld_function_make(const zbx_lld_function_t *function_proto, zbx_vector_ptr_t *functions, zbx_uint64_t itemid, const struct zbx_json_parse *jp_row, const zbx_vector_ptr_t *lld_macros, char **error) { int i, ret, function_found = 0; zbx_lld_function_t *function = NULL; char *proto_parameter = NULL; for (i = 0; i < functions->values_num; i++) { function = (zbx_lld_function_t *)functions->values[i]; if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_DISCOVERED)) continue; if (function->index == function_proto->index) { function_found = 1; break; } } if (FAIL == (ret = lld_parameter_make(function_proto->parameter, &proto_parameter, jp_row, lld_macros, error))) goto clean; if (0 == function_found) { function = (zbx_lld_function_t *)zbx_malloc(NULL, sizeof(zbx_lld_function_t)); function->index = function_proto->index; function->functionid = 0; function->itemid = itemid; function->itemid_orig = 0; function->function = zbx_strdup(NULL, function_proto->function); function->function_orig = NULL; function->parameter = proto_parameter; proto_parameter = NULL; function->parameter_orig = NULL; function->flags = ZBX_FLAG_LLD_FUNCTION_DISCOVERED; zbx_vector_ptr_append(functions, function); } else { if (function->itemid != itemid) { function->itemid_orig = function->itemid; function->itemid = itemid; function->flags |= ZBX_FLAG_LLD_FUNCTION_UPDATE_ITEMID; } if (0 != strcmp(function->function, function_proto->function)) { function->function_orig = function->function; function->function = zbx_strdup(NULL, function_proto->function); function->flags |= ZBX_FLAG_LLD_FUNCTION_UPDATE_FUNCTION; } if (0 != strcmp(function->parameter, proto_parameter)) { function->parameter_orig = function->parameter; function->parameter = proto_parameter; proto_parameter = NULL; function->flags |= ZBX_FLAG_LLD_FUNCTION_UPDATE_PARAMETER; } function->flags |= ZBX_FLAG_LLD_FUNCTION_DISCOVERED; } clean: zbx_free(proto_parameter); return ret; } static void lld_functions_delete(zbx_vector_ptr_t *functions) { int i; for (i = 0; i < functions->values_num; i++) { zbx_lld_function_t *function = (zbx_lld_function_t *)functions->values[i]; if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_DISCOVERED)) continue; function->flags |= ZBX_FLAG_LLD_FUNCTION_DELETE; } } static int lld_functions_make(const zbx_vector_ptr_t *functions_proto, zbx_vector_ptr_t *functions, const zbx_vector_ptr_t *items, const zbx_vector_ptr_t *item_links, const struct zbx_json_parse *jp_row, const zbx_vector_ptr_t *lld_macros, char **error) { int i, index, ret = FAIL; const zbx_lld_function_t *function_proto; const zbx_lld_item_t *item_proto; const zbx_lld_item_link_t *item_link; zbx_uint64_t itemid; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); for (i = 0; i < functions_proto->values_num; i++) { function_proto = (zbx_lld_function_t *)functions_proto->values[i]; index = zbx_vector_ptr_bsearch(items, &function_proto->itemid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); if (FAIL == index) goto out; item_proto = (zbx_lld_item_t *)items->values[index]; if (0 != (item_proto->flags & ZBX_FLAG_DISCOVERY_PROTOTYPE)) { index = zbx_vector_ptr_bsearch(item_links, &item_proto->itemid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); if (FAIL == index) goto out; item_link = (zbx_lld_item_link_t *)item_links->values[index]; itemid = item_link->itemid; } else itemid = item_proto->itemid; if (FAIL == lld_function_make(function_proto, functions, itemid, jp_row, lld_macros, error)) goto out; } lld_functions_delete(functions); ret = SUCCEED; out: zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret)); return ret; } /****************************************************************************** * * * Function: lld_trigger_make * * * * Purpose: create a trigger based on lld rule and add it to the list * * * ******************************************************************************/ static void lld_trigger_make(const zbx_lld_trigger_prototype_t *trigger_prototype, zbx_vector_ptr_t *triggers, const zbx_vector_ptr_t *items, zbx_hashset_t *items_triggers, const zbx_lld_row_t *lld_row, const zbx_vector_ptr_t *lld_macros, char **error) { zbx_lld_trigger_t *trigger; char *buffer = NULL, *expression = NULL, *recovery_expression = NULL, err[64]; char *err_msg = NULL; const char *operation_msg; const struct zbx_json_parse *jp_row = &lld_row->jp_row; unsigned char discover; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); trigger = lld_trigger_get(trigger_prototype->triggerid, items_triggers, &lld_row->item_links); operation_msg = NULL != trigger ? "update" : "create"; expression = zbx_strdup(expression, trigger_prototype->expression); recovery_expression = zbx_strdup(recovery_expression, trigger_prototype->recovery_expression); if (SUCCEED != substitute_lld_macros(&expression, jp_row, lld_macros, ZBX_MACRO_ANY | ZBX_TOKEN_TRIGGER, err, sizeof(err)) || SUCCEED != substitute_lld_macros(&recovery_expression, jp_row, lld_macros, ZBX_MACRO_ANY | ZBX_TOKEN_TRIGGER, err, sizeof(err))) { *error = zbx_strdcatf(*error, "Cannot %s trigger: %s.\n", operation_msg, err); goto out; } discover = trigger_prototype->discover; if (NULL != trigger) { unsigned char priority; buffer = zbx_strdup(buffer, trigger_prototype->description); substitute_lld_macros(&buffer, jp_row, lld_macros, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); priority = trigger_prototype->priority; lld_override_trigger(&lld_row->overrides, buffer, &priority, &trigger->override_tags, NULL, &discover); if (ZBX_PROTOTYPE_NO_DISCOVER == discover) goto out; if (0 != strcmp(trigger->description, buffer)) { trigger->description_orig = trigger->description; trigger->description = buffer; buffer = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION; } if (trigger->priority != priority) { trigger->priority = priority; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_PRIORITY; } if (0 != strcmp(trigger->expression, expression)) { trigger->expression_orig = trigger->expression; trigger->expression = expression; expression = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION; } if (0 != strcmp(trigger->recovery_expression, recovery_expression)) { trigger->recovery_expression_orig = trigger->recovery_expression; trigger->recovery_expression = recovery_expression; recovery_expression = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION; } buffer = zbx_strdup(buffer, trigger_prototype->comments); substitute_lld_macros(&buffer, jp_row, lld_macros, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(trigger->comments, buffer)) { trigger->comments_orig = trigger->comments; trigger->comments = buffer; buffer = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_COMMENTS; } buffer = zbx_strdup(buffer, trigger_prototype->url); substitute_lld_macros(&buffer, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(trigger->url, buffer)) { trigger->url_orig = trigger->url; trigger->url = buffer; buffer = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_URL; } buffer = zbx_strdup(buffer, trigger_prototype->correlation_tag); substitute_lld_macros(&buffer, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(trigger->correlation_tag, buffer)) { trigger->correlation_tag_orig = trigger->correlation_tag; trigger->correlation_tag = buffer; buffer = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_TAG; } buffer = zbx_strdup(buffer, trigger_prototype->opdata); substitute_lld_macros(&buffer, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(trigger->opdata, buffer)) { trigger->opdata_orig = trigger->opdata; trigger->opdata = buffer; buffer = NULL; trigger->flags |= ZBX_FLAG_LLD_TRIGGER_UPDATE_OPDATA; } } else { trigger = (zbx_lld_trigger_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_t)); trigger->triggerid = 0; trigger->lastcheck = 0; trigger->ts_delete = 0; trigger->parent_triggerid = trigger_prototype->triggerid; trigger->description = zbx_strdup(NULL, trigger_prototype->description); trigger->description_orig = NULL; substitute_lld_macros(&trigger->description, jp_row, lld_macros, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(trigger->description, ZBX_WHITESPACE); trigger->status = trigger_prototype->status; trigger->priority = trigger_prototype->priority; zbx_vector_ptr_pair_create(&trigger->override_tags); lld_override_trigger(&lld_row->overrides, trigger->description, &trigger->priority, &trigger->override_tags, &trigger->status, &discover); if (ZBX_PROTOTYPE_NO_DISCOVER == discover) { zbx_vector_ptr_pair_destroy(&trigger->override_tags); zbx_free(trigger->description); zbx_free(trigger); goto out; } trigger->expression = expression; trigger->expression_orig = NULL; expression = NULL; trigger->recovery_expression = recovery_expression; trigger->recovery_expression_orig = NULL; recovery_expression = NULL; trigger->comments = zbx_strdup(NULL, trigger_prototype->comments); trigger->comments_orig = NULL; substitute_lld_macros(&trigger->comments, jp_row, lld_macros, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(trigger->comments, ZBX_WHITESPACE); trigger->url = zbx_strdup(NULL, trigger_prototype->url); trigger->url_orig = NULL; substitute_lld_macros(&trigger->url, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(trigger->url, ZBX_WHITESPACE); trigger->correlation_tag = zbx_strdup(NULL, trigger_prototype->correlation_tag); trigger->correlation_tag_orig = NULL; substitute_lld_macros(&trigger->correlation_tag, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(trigger->correlation_tag, ZBX_WHITESPACE); trigger->opdata = zbx_strdup(NULL, trigger_prototype->opdata); trigger->opdata_orig = NULL; substitute_lld_macros(&trigger->opdata, jp_row, lld_macros, ZBX_MACRO_ANY, NULL, 0); zbx_lrtrim(trigger->opdata, ZBX_WHITESPACE); zbx_vector_ptr_create(&trigger->functions); zbx_vector_ptr_create(&trigger->dependencies); zbx_vector_ptr_create(&trigger->dependents); zbx_vector_ptr_create(&trigger->tags); trigger->flags = ZBX_FLAG_LLD_TRIGGER_UNSET; zbx_vector_ptr_append(triggers, trigger); } if (SUCCEED != lld_functions_make(&trigger_prototype->functions, &trigger->functions, items, &lld_row->item_links, jp_row, lld_macros, &err_msg)) { if (err_msg) { *error = zbx_strdcatf(*error, "Cannot %s trigger: %s.\n", operation_msg, err_msg); zbx_free(err_msg); } goto out; } trigger->flags |= ZBX_FLAG_LLD_TRIGGER_DISCOVERED; out: zbx_free(recovery_expression); zbx_free(expression); zbx_free(buffer); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } static zbx_hash_t items_triggers_hash_func(const void *data) { const zbx_lld_item_trigger_t *item_trigger = (zbx_lld_item_trigger_t *)data; zbx_hash_t hash; hash = ZBX_DEFAULT_UINT64_HASH_FUNC(&item_trigger->parent_triggerid); hash = ZBX_DEFAULT_UINT64_HASH_ALGO(&item_trigger->itemid, sizeof(zbx_uint64_t), hash); return hash; } static int items_triggers_compare_func(const void *d1, const void *d2) { const zbx_lld_item_trigger_t *item_trigger1 = (zbx_lld_item_trigger_t *)d1, *item_trigger2 = (zbx_lld_item_trigger_t *)d2; ZBX_RETURN_IF_NOT_EQUAL(item_trigger1->parent_triggerid, item_trigger2->parent_triggerid); ZBX_RETURN_IF_NOT_EQUAL(item_trigger1->itemid, item_trigger2->itemid); return 0; } static void lld_triggers_make(const zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers, const zbx_vector_ptr_t *items, const zbx_vector_ptr_t *lld_rows, const zbx_vector_ptr_t *lld_macro_paths, char **error) { const zbx_lld_trigger_prototype_t *trigger_prototype; int i, j; zbx_hashset_t items_triggers; zbx_lld_trigger_t *trigger; const zbx_lld_function_t *function; zbx_lld_item_trigger_t item_trigger; /* used for fast search of trigger by item prototype */ zbx_hashset_create(&items_triggers, 512, items_triggers_hash_func, items_triggers_compare_func); for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; for (j = 0; j < trigger->functions.values_num; j++) { function = (zbx_lld_function_t *)trigger->functions.values[j]; item_trigger.parent_triggerid = trigger->parent_triggerid; item_trigger.itemid = function->itemid; item_trigger.trigger = trigger; zbx_hashset_insert(&items_triggers, &item_trigger, sizeof(item_trigger)); } } for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; for (j = 0; j < lld_rows->values_num; j++) { zbx_lld_row_t *lld_row = (zbx_lld_row_t *)lld_rows->values[j]; lld_trigger_make(trigger_prototype, triggers, items, &items_triggers, lld_row, lld_macro_paths, error); } } zbx_hashset_destroy(&items_triggers); zbx_vector_ptr_sort(triggers, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } /****************************************************************************** * * * Function: lld_trigger_dependency_make * * * * Purpose: create a trigger dependencies * * * ******************************************************************************/ static void lld_trigger_dependency_make(const zbx_lld_trigger_prototype_t *trigger_prototype, const zbx_vector_ptr_t *trigger_prototypes, zbx_hashset_t *items_triggers, const zbx_lld_row_t *lld_row, char **error) { zbx_lld_trigger_t *trigger, *dep_trigger; const zbx_lld_trigger_prototype_t *dep_trigger_prototype; zbx_lld_dependency_t *dependency; zbx_uint64_t triggerid_up; int i, j, index; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); if (NULL == (trigger = lld_trigger_get(trigger_prototype->triggerid, items_triggers, &lld_row->item_links))) goto out; for (i = 0; i < trigger_prototype->dependencies.values_num; i++) { triggerid_up = ((zbx_lld_dependency_t *)trigger_prototype->dependencies.values[i])->triggerid_up; index = zbx_vector_ptr_bsearch(trigger_prototypes, &triggerid_up, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); if (FAIL != index) { /* creating trigger dependency based on trigger prototype */ dep_trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; dep_trigger = lld_trigger_get(dep_trigger_prototype->triggerid, items_triggers, &lld_row->item_links); if (NULL != dep_trigger) { if (0 == dep_trigger->triggerid) { dependency = (zbx_lld_dependency_t *)zbx_malloc(NULL, sizeof(zbx_lld_dependency_t)); dependency->triggerdepid = 0; dependency->triggerid_up = 0; zbx_vector_ptr_append(&trigger->dependencies, dependency); } else { int dependency_found = 0; for (j = 0; j < trigger->dependencies.values_num; j++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 != (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) continue; if (dependency->triggerid_up == dep_trigger->triggerid) { dependency_found = 1; break; } } if (0 == dependency_found) { dependency = (zbx_lld_dependency_t *)zbx_malloc(NULL, sizeof(zbx_lld_dependency_t)); dependency->triggerdepid = 0; dependency->triggerid_up = dep_trigger->triggerid; zbx_vector_ptr_append(&trigger->dependencies, dependency); } } zbx_vector_ptr_append(&dep_trigger->dependents, trigger); dependency->trigger_up = dep_trigger; dependency->flags = ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED; } else { *error = zbx_strdcatf(*error, "Cannot create dependency on trigger \"%s\".\n", trigger->description); } } else { /* creating trigger dependency based on generic trigger */ for (j = 0; j < trigger->dependencies.values_num; j++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 != (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) continue; if (dependency->triggerid_up == triggerid_up) break; } if (j == trigger->dependencies.values_num) { dependency = (zbx_lld_dependency_t *)zbx_malloc(NULL, sizeof(zbx_lld_dependency_t)); dependency->triggerdepid = 0; dependency->triggerid_up = triggerid_up; dependency->trigger_up = NULL; zbx_vector_ptr_append(&trigger->dependencies, dependency); } dependency->flags = ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED; } } out: zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } static void lld_trigger_dependencies_make(const zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers, const zbx_vector_ptr_t *lld_rows, char **error) { const zbx_lld_trigger_prototype_t *trigger_prototype; int i, j; zbx_hashset_t items_triggers; zbx_lld_trigger_t *trigger; zbx_lld_function_t *function; zbx_lld_item_trigger_t item_trigger; zbx_lld_dependency_t *dependency; for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; if (0 != trigger_prototype->dependencies.values_num) break; } for (j = 0; j < triggers->values_num; j++) { trigger = (zbx_lld_trigger_t *)triggers->values[j]; if (0 != trigger->dependencies.values_num) break; } /* all trigger prototypes and triggers have no dependencies */ if (i == trigger_prototypes->values_num && j == triggers->values_num) return; /* used for fast search of trigger by item prototype */ zbx_hashset_create(&items_triggers, 512, items_triggers_hash_func, items_triggers_compare_func); for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->functions.values_num; j++) { function = (zbx_lld_function_t *)trigger->functions.values[j]; item_trigger.parent_triggerid = trigger->parent_triggerid; item_trigger.itemid = function->itemid; item_trigger.trigger = trigger; zbx_hashset_insert(&items_triggers, &item_trigger, sizeof(item_trigger)); } } for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; for (j = 0; j < lld_rows->values_num; j++) { zbx_lld_row_t *lld_row = (zbx_lld_row_t *)lld_rows->values[j]; lld_trigger_dependency_make(trigger_prototype, trigger_prototypes, &items_triggers, lld_row, error); } } /* marking dependencies which will be deleted */ for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->dependencies.values_num; j++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 == (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) dependency->flags = ZBX_FLAG_LLD_DEPENDENCY_DELETE; } } zbx_hashset_destroy(&items_triggers); zbx_vector_ptr_sort(triggers, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } static int ptr_pair_compare_func(const void *d1, const void *d2) { const zbx_ptr_pair_t *pair1 = (const zbx_ptr_pair_t *)d1; const zbx_ptr_pair_t *pair2 = (const zbx_ptr_pair_t *)d2; int ret; if (0 != (ret = strcmp((char *)pair1->first, (char *)pair2->first))) return ret; return strcmp((char *)pair1->second, (char *)pair2->second); } /****************************************************************************** * * * Function: lld_trigger_tag_make * * * * Purpose: create a trigger tag * * * ******************************************************************************/ static void lld_trigger_tag_make(zbx_lld_trigger_prototype_t *trigger_prototype, zbx_hashset_t *items_triggers, zbx_lld_row_t *lld_row, const zbx_vector_ptr_t *lld_macro_paths) { zbx_lld_trigger_t *trigger; int i; zbx_lld_tag_t *tag; char *buffer = NULL; const char *key, *value; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); if (NULL == (trigger = lld_trigger_get(trigger_prototype->triggerid, items_triggers, &lld_row->item_links))) goto out; zbx_vector_ptr_pair_sort(&trigger->override_tags, ptr_pair_compare_func); for (i = 0; i < trigger_prototype->tags.values_num + trigger->override_tags.values_num; i++) { if (i < trigger_prototype->tags.values_num) { zbx_lld_tag_t *tag_proto; tag_proto = (zbx_lld_tag_t *)trigger_prototype->tags.values[i]; key = tag_proto->tag; value = tag_proto->value; } else { zbx_ptr_pair_t pair; pair = trigger->override_tags.values[i - trigger_prototype->tags.values_num]; key = pair.first; value = pair.second; } if (i < trigger->tags.values_num) { tag = (zbx_lld_tag_t *)trigger->tags.values[i]; buffer = zbx_strdup(buffer, key); substitute_lld_macros(&buffer, &lld_row->jp_row, lld_macro_paths, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(buffer, tag->tag)) { zbx_free(tag->tag); tag->tag = buffer; buffer = NULL; tag->flags |= ZBX_FLAG_LLD_TAG_UPDATE_TAG; } buffer = zbx_strdup(buffer, value); substitute_lld_macros(&buffer, &lld_row->jp_row, lld_macro_paths, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(buffer, ZBX_WHITESPACE); if (0 != strcmp(buffer, tag->value)) { zbx_free(tag->value); tag->value = buffer; buffer = NULL; tag->flags |= ZBX_FLAG_LLD_TAG_UPDATE_VALUE; } } else { tag = (zbx_lld_tag_t *)zbx_malloc(NULL, sizeof(zbx_lld_tag_t)); tag->triggertagid = 0; tag->tag = zbx_strdup(NULL, key); substitute_lld_macros(&tag->tag, &lld_row->jp_row, lld_macro_paths, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(tag->tag, ZBX_WHITESPACE); tag->value = zbx_strdup(NULL, value); substitute_lld_macros(&tag->value, &lld_row->jp_row, lld_macro_paths, ZBX_MACRO_FUNC, NULL, 0); zbx_lrtrim(tag->value, ZBX_WHITESPACE); tag->flags = ZBX_FLAG_LLD_TAG_UNSET; zbx_vector_ptr_append(&trigger->tags, tag); } tag->flags |= ZBX_FLAG_LLD_TAG_DISCOVERED; } out: zbx_free(buffer); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_trigger_tags_make * * * * Purpose: create a trigger tags * * * ******************************************************************************/ static void lld_trigger_tags_make(zbx_vector_ptr_t *trigger_prototypes, zbx_vector_ptr_t *triggers, const zbx_vector_ptr_t *lld_rows, const zbx_vector_ptr_t *lld_macro_paths) { zbx_lld_trigger_prototype_t *trigger_prototype; int i, j; zbx_hashset_t items_triggers; zbx_lld_trigger_t *trigger; zbx_lld_function_t *function; zbx_lld_item_trigger_t item_trigger; zbx_lld_tag_t *tag; /* used for fast search of trigger by item prototype */ zbx_hashset_create(&items_triggers, 512, items_triggers_hash_func, items_triggers_compare_func); for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->functions.values_num; j++) { function = (zbx_lld_function_t *)trigger->functions.values[j]; item_trigger.parent_triggerid = trigger->parent_triggerid; item_trigger.itemid = function->itemid; item_trigger.trigger = trigger; zbx_hashset_insert(&items_triggers, &item_trigger, sizeof(item_trigger)); } } for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; for (j = 0; j < lld_rows->values_num; j++) { zbx_lld_row_t *lld_row = (zbx_lld_row_t *)lld_rows->values[j]; lld_trigger_tag_make(trigger_prototype, &items_triggers, lld_row, lld_macro_paths); } } /* marking tags which will be deleted */ for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->tags.values_num; j++) { tag = (zbx_lld_tag_t *)trigger->tags.values[j]; if (0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) tag->flags = ZBX_FLAG_LLD_TAG_DELETE; } } zbx_hashset_destroy(&items_triggers); zbx_vector_ptr_sort(triggers, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); } /****************************************************************************** * * * Function: lld_validate_trigger_field * * * ******************************************************************************/ static void lld_validate_trigger_field(zbx_lld_trigger_t *trigger, char **field, char **field_orig, zbx_uint64_t flag, size_t field_len, char **error) { if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) return; /* only new triggers or triggers with changed data will be validated */ if (0 != trigger->triggerid && 0 == (trigger->flags & flag)) return; if (SUCCEED != zbx_is_utf8(*field)) { zbx_replace_invalid_utf8(*field); *error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" has invalid UTF-8 sequence.\n", (0 != trigger->triggerid ? "update" : "create"), *field); } else if (zbx_strlen_utf8(*field) > field_len) { *error = zbx_strdcatf(*error, "Cannot %s trigger: value \"%s\" is too long.\n", (0 != trigger->triggerid ? "update" : "create"), *field); } else if (ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION == flag && '\0' == **field) { *error = zbx_strdcatf(*error, "Cannot %s trigger: name is empty.\n", (0 != trigger->triggerid ? "update" : "create")); } else return; if (0 != trigger->triggerid) lld_field_str_rollback(field, field_orig, &trigger->flags, flag); else trigger->flags &= ~ZBX_FLAG_LLD_TRIGGER_DISCOVERED; } /****************************************************************************** * * * Function: lld_trigger_changed * * * * Return value: returns SUCCEED if a trigger description or expression has * * been changed; FAIL - otherwise * * * ******************************************************************************/ static int lld_trigger_changed(const zbx_lld_trigger_t *trigger) { int i; zbx_lld_function_t *function; if (0 == trigger->triggerid) return SUCCEED; if (0 != (trigger->flags & (ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION | ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION | ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION))) { return SUCCEED; } for (i = 0; i < trigger->functions.values_num; i++) { function = (zbx_lld_function_t *)trigger->functions.values[i]; if (0 == function->functionid) { THIS_SHOULD_NEVER_HAPPEN; return SUCCEED; } if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_UPDATE)) return SUCCEED; } return FAIL; } /****************************************************************************** * * * Function: lld_triggers_equal * * * * Return value: returns SUCCEED if descriptions and expressions of * * the triggers are identical; FAIL - otherwise * * * ******************************************************************************/ static int lld_triggers_equal(const zbx_lld_trigger_t *trigger, const zbx_lld_trigger_t *trigger_b) { int ret = FAIL; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); if (0 == strcmp(trigger->description, trigger_b->description)) { char *expression, *expression_b; expression = lld_expression_expand(trigger->expression, &trigger->functions); expression_b = lld_expression_expand(trigger_b->expression, &trigger_b->functions); if (0 == strcmp(expression, expression_b)) { zbx_free(expression); zbx_free(expression_b); expression = lld_expression_expand(trigger->recovery_expression, &trigger->functions); expression_b = lld_expression_expand(trigger_b->recovery_expression, &trigger_b->functions); if (0 == strcmp(expression, expression_b)) ret = SUCCEED; } zbx_free(expression); zbx_free(expression_b); } zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret)); return ret; } /****************************************************************************** * * * Function: lld_triggers_validate * * * * Parameters: triggers - [IN] sorted list of triggers * * * ******************************************************************************/ static void lld_triggers_validate(zbx_uint64_t hostid, zbx_vector_ptr_t *triggers, char **error) { int i, j, k; zbx_lld_trigger_t *trigger; zbx_lld_function_t *function; zbx_vector_uint64_t triggerids; zbx_vector_str_t descriptions; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_uint64_create(&triggerids); zbx_vector_str_create(&descriptions); /* checking a validity of the fields */ for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; lld_validate_trigger_field(trigger, &trigger->description, &trigger->description_orig, ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION, TRIGGER_DESCRIPTION_LEN, error); lld_validate_trigger_field(trigger, &trigger->comments, &trigger->comments_orig, ZBX_FLAG_LLD_TRIGGER_UPDATE_COMMENTS, TRIGGER_COMMENTS_LEN, error); lld_validate_trigger_field(trigger, &trigger->url, &trigger->url_orig, ZBX_FLAG_LLD_TRIGGER_UPDATE_URL, TRIGGER_URL_LEN, error); lld_validate_trigger_field(trigger, &trigger->correlation_tag, &trigger->correlation_tag_orig, ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_TAG, TAG_NAME_LEN, error); lld_validate_trigger_field(trigger, &trigger->opdata, &trigger->opdata_orig, ZBX_FLAG_LLD_TRIGGER_UPDATE_OPDATA, TRIGGER_OPDATA_LEN, error); } /* checking duplicated triggers in DB */ for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; if (0 != trigger->triggerid) { zbx_vector_uint64_append(&triggerids, trigger->triggerid); if (SUCCEED != lld_trigger_changed(trigger)) continue; } zbx_vector_str_append(&descriptions, trigger->description); } if (0 != descriptions.values_num) { char *sql = NULL; size_t sql_alloc = 256, sql_offset = 0; DB_RESULT result; DB_ROW row; zbx_vector_ptr_t db_triggers; zbx_lld_trigger_t *db_trigger; zbx_vector_ptr_create(&db_triggers); zbx_vector_str_sort(&descriptions, ZBX_DEFAULT_STR_COMPARE_FUNC); zbx_vector_str_uniq(&descriptions, ZBX_DEFAULT_STR_COMPARE_FUNC); sql = (char *)zbx_malloc(sql, sql_alloc); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "select distinct t.triggerid,t.description,t.expression,t.recovery_expression" " from triggers t,functions f,items i" " where t.triggerid=f.triggerid" " and f.itemid=i.itemid" " and i.hostid=" ZBX_FS_UI64 " and", hostid); DBadd_str_condition_alloc(&sql, &sql_alloc, &sql_offset, "t.description", (const char **)descriptions.values, descriptions.values_num); if (0 != triggerids.values_num) { zbx_vector_uint64_sort(&triggerids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, " and not"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "t.triggerid", triggerids.values, triggerids.values_num); } result = DBselect("%s", sql); while (NULL != (row = DBfetch(result))) { db_trigger = (zbx_lld_trigger_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_t)); ZBX_STR2UINT64(db_trigger->triggerid, row[0]); db_trigger->description = zbx_strdup(NULL, row[1]); db_trigger->description_orig = NULL; db_trigger->expression = zbx_strdup(NULL, row[2]); db_trigger->expression_orig = NULL; db_trigger->recovery_expression = zbx_strdup(NULL, row[3]); db_trigger->recovery_expression_orig = NULL; db_trigger->comments = NULL; db_trigger->comments_orig = NULL; db_trigger->url = NULL; db_trigger->url_orig = NULL; db_trigger->correlation_tag = NULL; db_trigger->correlation_tag_orig = NULL; db_trigger->opdata = NULL; db_trigger->opdata_orig = NULL; db_trigger->flags = ZBX_FLAG_LLD_TRIGGER_UNSET; zbx_vector_ptr_create(&db_trigger->functions); zbx_vector_ptr_create(&db_trigger->dependencies); zbx_vector_ptr_create(&db_trigger->dependents); zbx_vector_ptr_create(&db_trigger->tags); zbx_vector_ptr_pair_create(&db_trigger->override_tags); zbx_vector_ptr_append(&db_triggers, db_trigger); } DBfree_result(result); zbx_vector_ptr_sort(&db_triggers, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); lld_functions_get(NULL, &db_triggers); for (i = 0; i < db_triggers.values_num; i++) { db_trigger = (zbx_lld_trigger_t *)db_triggers.values[i]; lld_expressions_simplify(&db_trigger->expression, &db_trigger->recovery_expression, &db_trigger->functions); for (j = 0; j < triggers->values_num; j++) { trigger = (zbx_lld_trigger_t *)triggers->values[j]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; if (SUCCEED != lld_triggers_equal(trigger, db_trigger)) continue; *error = zbx_strdcatf(*error, "Cannot %s trigger: trigger \"%s\" already exists.\n", (0 != trigger->triggerid ? "update" : "create"), trigger->description); if (0 != trigger->triggerid) { lld_field_str_rollback(&trigger->description, &trigger->description_orig, &trigger->flags, ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION); lld_field_str_rollback(&trigger->expression, &trigger->expression_orig, &trigger->flags, ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION); lld_field_str_rollback(&trigger->recovery_expression, &trigger->recovery_expression_orig, &trigger->flags, ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION); for (k = 0; k < trigger->functions.values_num; k++) { function = (zbx_lld_function_t *)trigger->functions.values[k]; if (0 != function->functionid) { lld_field_uint64_rollback(&function->itemid, &function->itemid_orig, &function->flags, ZBX_FLAG_LLD_FUNCTION_UPDATE_ITEMID); lld_field_str_rollback(&function->function, &function->function_orig, &function->flags, ZBX_FLAG_LLD_FUNCTION_UPDATE_FUNCTION); lld_field_str_rollback(&function->parameter, &function->parameter_orig, &function->flags, ZBX_FLAG_LLD_FUNCTION_UPDATE_PARAMETER); function->flags &= ~ZBX_FLAG_LLD_FUNCTION_DELETE; } else function->flags &= ~ZBX_FLAG_LLD_FUNCTION_DISCOVERED; } } else trigger->flags &= ~ZBX_FLAG_LLD_TRIGGER_DISCOVERED; break; /* only one same trigger can be here */ } } zbx_vector_ptr_clear_ext(&db_triggers, (zbx_clean_func_t)lld_trigger_free); zbx_vector_ptr_destroy(&db_triggers); zbx_free(sql); } zbx_vector_str_destroy(&descriptions); zbx_vector_uint64_destroy(&triggerids); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: lld_validate_trigger_tag_field * * * ******************************************************************************/ static void lld_validate_trigger_tag_field(zbx_lld_tag_t *tag, const char *field, zbx_uint64_t flag, size_t field_len, char **error) { size_t len; if (0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) return; /* only new trigger tags or tags with changed data will be validated */ if (0 != tag->triggertagid && 0 == (tag->flags & flag)) return; if (SUCCEED != zbx_is_utf8(field)) { char *field_utf8; field_utf8 = zbx_strdup(NULL, field); zbx_replace_invalid_utf8(field_utf8); *error = zbx_strdcatf(*error, "Cannot create trigger tag: value \"%s\" has invalid UTF-8 sequence.\n", field_utf8); zbx_free(field_utf8); } else if ((len = zbx_strlen_utf8(field)) > field_len) *error = zbx_strdcatf(*error, "Cannot create trigger tag: value \"%s\" is too long.\n", field); else if (0 != (flag & ZBX_FLAG_LLD_TAG_UPDATE_TAG) && 0 == len) *error = zbx_strdcatf(*error, "Cannot create trigger tag: empty tag name.\n"); else return; if (0 != tag->triggertagid) tag->flags = ZBX_FLAG_LLD_TAG_DELETE; else tag->flags &= ~ZBX_FLAG_LLD_TAG_DISCOVERED; } /****************************************************************************** * * * Function: lld_trigger_tags_validate * * * * Purpose: validate created or updated trigger tags * * * ******************************************************************************/ static void lld_trigger_tags_validate(zbx_vector_ptr_t *triggers, char **error) { int i, j, k; zbx_lld_trigger_t *trigger; zbx_lld_tag_t *tag, *tag_tmp; for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->tags.values_num; j++) { tag = (zbx_lld_tag_t *)trigger->tags.values[j]; lld_validate_trigger_tag_field(tag, tag->tag, ZBX_FLAG_LLD_TAG_UPDATE_TAG, TAG_NAME_LEN, error); lld_validate_trigger_tag_field(tag, tag->value, ZBX_FLAG_LLD_TAG_UPDATE_VALUE, TAG_VALUE_LEN, error); if (0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) continue; /* check for duplicated tag,values pairs */ for (k = 0; k < j; k++) { tag_tmp = (zbx_lld_tag_t *)trigger->tags.values[k]; if (0 == strcmp(tag->tag, tag_tmp->tag) && 0 == strcmp(tag->value, tag_tmp->value)) { *error = zbx_strdcatf(*error, "Cannot create trigger tag: tag \"%s\"," "\"%s\" already exists.\n", tag->tag, tag->value); if (0 != tag->triggertagid) tag->flags = ZBX_FLAG_LLD_TAG_DELETE; else tag->flags &= ~ZBX_FLAG_LLD_TAG_DISCOVERED; } } /* reset trigger discovery flags for new trigger if tag discovery failed */ if (0 == trigger->triggerid && 0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) { trigger->flags &= ~ZBX_FLAG_LLD_TRIGGER_DISCOVERED; break; } } } } /****************************************************************************** * * * Function: lld_expression_create * * * * Purpose: transforms the simple trigger expression to the DB format * * * * Example: * * * * "{1} > 5" => "{84756} > 5" * * ^ ^ * * | functionid from the database * * internal function index * * * ******************************************************************************/ static void lld_expression_create(char **expression, const zbx_vector_ptr_t *functions) { size_t l, r; int i; zbx_uint64_t function_index; char buffer[ZBX_MAX_UINT64_LEN]; zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __func__, *expression); for (l = 0; '\0' != (*expression)[l]; l++) { if ('{' != (*expression)[l]) continue; if ('$' == (*expression)[l + 1]) { int macro_r, context_l, context_r; if (SUCCEED == zbx_user_macro_parse(*expression + l, ¯o_r, &context_l, &context_r, NULL)) l += macro_r; else l++; continue; } for (r = l + 1; '\0' != (*expression)[r] && '}' != (*expression)[r]; r++) ; if ('}' != (*expression)[r]) continue; /* ... > 0 | {1} + ... */ /* l r */ if (SUCCEED != is_uint64_n(*expression + l + 1, r - l - 1, &function_index)) continue; for (i = 0; i < functions->values_num; i++) { const zbx_lld_function_t *function = (zbx_lld_function_t *)functions->values[i]; if (function->index != function_index) continue; zbx_snprintf(buffer, sizeof(buffer), ZBX_FS_UI64, function->functionid); r--; zbx_replace_string(expression, l + 1, &r, buffer); r++; break; } l = r; } zabbix_log(LOG_LEVEL_DEBUG, "End of %s() expression:'%s'", __func__, *expression); } /****************************************************************************** * * * Function: lld_triggers_save * * * * Purpose: add or update triggers in database based on discovery rule * * * * Parameters: hostid - [IN] parent host id * * lld_triggers_save - [IN] trigger prototypes * * triggers - [IN/OUT] triggers to save * * * * Return value: SUCCEED - if triggers was successfully saved or saving * * was not necessary * * FAIL - triggers cannot be saved * * * ******************************************************************************/ static int lld_triggers_save(zbx_uint64_t hostid, const zbx_vector_ptr_t *trigger_prototypes, const zbx_vector_ptr_t *triggers) { int ret = SUCCEED, i, j, new_triggers = 0, upd_triggers = 0, new_functions = 0, new_dependencies = 0, new_tags = 0, upd_tags = 0; const zbx_lld_trigger_prototype_t *trigger_prototype; zbx_lld_trigger_t *trigger; zbx_lld_function_t *function; zbx_lld_dependency_t *dependency; zbx_lld_tag_t *tag; zbx_vector_ptr_t upd_functions; /* the ordered list of functions which will be updated */ zbx_vector_uint64_t del_functionids, del_triggerdepids, del_triggertagids, trigger_protoids; zbx_uint64_t triggerid = 0, functionid = 0, triggerdepid = 0, triggerid_up, triggertagid; char *sql = NULL, *function_esc, *parameter_esc; size_t sql_alloc = 8 * ZBX_KIBIBYTE, sql_offset = 0; zbx_db_insert_t db_insert, db_insert_tdiscovery, db_insert_tfunctions, db_insert_tdepends, db_insert_ttags; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_ptr_create(&upd_functions); zbx_vector_uint64_create(&del_functionids); zbx_vector_uint64_create(&del_triggerdepids); zbx_vector_uint64_create(&del_triggertagids); zbx_vector_uint64_create(&trigger_protoids); for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; if (0 == trigger->triggerid) new_triggers++; else if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE)) upd_triggers++; for (j = 0; j < trigger->functions.values_num; j++) { function = (zbx_lld_function_t *)trigger->functions.values[j]; if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_DELETE)) { zbx_vector_uint64_append(&del_functionids, function->functionid); continue; } if (0 == (function->flags & ZBX_FLAG_LLD_FUNCTION_DISCOVERED)) continue; if (0 == function->functionid) new_functions++; else if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_UPDATE)) zbx_vector_ptr_append(&upd_functions, function); } for (j = 0; j < trigger->dependencies.values_num; j++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 != (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DELETE)) { zbx_vector_uint64_append(&del_triggerdepids, dependency->triggerdepid); continue; } if (0 == (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) continue; if (0 == dependency->triggerdepid) new_dependencies++; } for (j = 0; j < trigger->tags.values_num; j++) { tag = (zbx_lld_tag_t *)trigger->tags.values[j]; if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_DELETE)) { zbx_vector_uint64_append(&del_triggertagids, tag->triggertagid); continue; } if (0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) continue; if (0 == tag->triggertagid) new_tags++; else if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_UPDATE)) upd_tags++; } } if (0 == new_triggers && 0 == new_functions && 0 == new_dependencies && 0 == upd_triggers && 0 == upd_functions.values_num && 0 == del_functionids.values_num && 0 == del_triggerdepids.values_num && 0 == new_tags && 0 == upd_tags && 0 == del_triggertagids.values_num) { goto out; } DBbegin(); for (i = 0; i < trigger_prototypes->values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[i]; zbx_vector_uint64_append(&trigger_protoids, trigger_prototype->triggerid); } if (SUCCEED != DBlock_hostid(hostid) || SUCCEED != DBlock_triggerids(&trigger_protoids)) { /* the host or trigger prototype was removed while processing lld rule */ DBrollback(); ret = FAIL; goto out; } if (0 != new_triggers) { triggerid = DBget_maxid_num("triggers", new_triggers); zbx_db_insert_prepare(&db_insert, "triggers", "triggerid", "description", "expression", "priority", "status", "comments", "url", "type", "value", "state", "flags", "recovery_mode", "recovery_expression", "correlation_mode", "correlation_tag", "manual_close", "opdata", NULL); zbx_db_insert_prepare(&db_insert_tdiscovery, "trigger_discovery", "triggerid", "parent_triggerid", NULL); } if (0 != new_functions) { functionid = DBget_maxid_num("functions", new_functions); zbx_db_insert_prepare(&db_insert_tfunctions, "functions", "functionid", "itemid", "triggerid", "name", "parameter", NULL); } if (0 != new_dependencies) { triggerdepid = DBget_maxid_num("trigger_depends", new_dependencies); zbx_db_insert_prepare(&db_insert_tdepends, "trigger_depends", "triggerdepid", "triggerid_down", "triggerid_up", NULL); } if (0 != new_tags) { triggertagid = DBget_maxid_num("trigger_tag", new_tags); zbx_db_insert_prepare(&db_insert_ttags, "trigger_tag", "triggertagid", "triggerid", "tag", "value", NULL); } if (0 != upd_triggers || 0 != upd_functions.values_num || 0 != del_functionids.values_num || 0 != del_triggerdepids.values_num || 0 != upd_tags || 0 != del_triggertagids.values_num) { sql = (char *)zbx_malloc(sql, sql_alloc); DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset); } for (i = 0; i < triggers->values_num; i++) { char *description_esc, *expression_esc, *comments_esc, *url_esc, *value_esc, *opdata_esc; int index; trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; index = zbx_vector_ptr_bsearch(trigger_prototypes, &trigger->parent_triggerid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes->values[index]; for (j = 0; j < trigger->functions.values_num; j++) { function = (zbx_lld_function_t *)trigger->functions.values[j]; if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_DELETE)) continue; if (0 == (function->flags & ZBX_FLAG_LLD_FUNCTION_DISCOVERED)) continue; if (0 == function->functionid) { zbx_db_insert_add_values(&db_insert_tfunctions, functionid, function->itemid, (0 == trigger->triggerid ? triggerid : trigger->triggerid), function->function, function->parameter); function->functionid = functionid++; } } if (0 == trigger->triggerid || 0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION)) lld_expression_create(&trigger->expression, &trigger->functions); if (0 == trigger->triggerid || 0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION)) lld_expression_create(&trigger->recovery_expression, &trigger->functions); if (0 == trigger->triggerid) { zbx_db_insert_add_values(&db_insert, triggerid, trigger->description, trigger->expression, (int)trigger->priority, (int)trigger->status, trigger->comments, trigger->url, (int)trigger_prototype->type, (int)TRIGGER_VALUE_OK, (int)TRIGGER_STATE_NORMAL, (int)ZBX_FLAG_DISCOVERY_CREATED, (int)trigger_prototype->recovery_mode, trigger->recovery_expression, (int)trigger_prototype->correlation_mode, trigger->correlation_tag, (int)trigger_prototype->manual_close, trigger->opdata); zbx_db_insert_add_values(&db_insert_tdiscovery, triggerid, trigger->parent_triggerid); trigger->triggerid = triggerid++; } else if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE)) { const char *d = ""; zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "update triggers set "); if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_DESCRIPTION)) { description_esc = DBdyn_escape_string(trigger->description); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "description='%s'", description_esc); zbx_free(description_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_EXPRESSION)) { expression_esc = DBdyn_escape_string(trigger->expression); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%sexpression='%s'", d, expression_esc); zbx_free(expression_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_EXPRESSION)) { expression_esc = DBdyn_escape_string(trigger->recovery_expression); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%srecovery_expression='%s'", d, expression_esc); zbx_free(expression_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_RECOVERY_MODE)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%srecovery_mode=%d", d, (int)trigger_prototype->recovery_mode); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_TYPE)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%stype=%d", d, (int)trigger_prototype->type); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_PRIORITY)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%spriority=%d", d, (int)trigger->priority); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_COMMENTS)) { comments_esc = DBdyn_escape_string(trigger->comments); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%scomments='%s'", d, comments_esc); zbx_free(comments_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_URL)) { url_esc = DBdyn_escape_string(trigger->url); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%surl='%s'", d, url_esc); zbx_free(url_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_MODE)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%scorrelation_mode=%d", d, (int)trigger_prototype->correlation_mode); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_CORRELATION_TAG)) { value_esc = DBdyn_escape_string(trigger->correlation_tag); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%scorrelation_tag='%s'", d, value_esc); zbx_free(value_esc); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_MANUAL_CLOSE)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%smanual_close=%d", d, (int)trigger_prototype->manual_close); d = ","; } if (0 != (trigger->flags & ZBX_FLAG_LLD_TRIGGER_UPDATE_OPDATA)) { opdata_esc = DBdyn_escape_string(trigger->opdata); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%sopdata='%s'", d, opdata_esc); zbx_free(opdata_esc); } zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " where triggerid=" ZBX_FS_UI64 ";\n", trigger->triggerid); } } for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->dependencies.values_num; j++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 != (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DELETE)) continue; if (0 == (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) continue; if (0 == dependency->triggerdepid) { triggerid_up = (NULL == dependency->trigger_up ? dependency->triggerid_up : dependency->trigger_up->triggerid); zbx_db_insert_add_values(&db_insert_tdepends, triggerdepid, trigger->triggerid, triggerid_up); dependency->triggerdepid = triggerdepid++; } } } /* create/update trigger tags */ for (i = 0; i < triggers->values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers->values[i]; if (0 == (trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED)) continue; for (j = 0; j < trigger->tags.values_num; j++) { char *value_esc; tag = (zbx_lld_tag_t *)trigger->tags.values[j]; if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_DELETE)) continue; if (0 == (tag->flags & ZBX_FLAG_LLD_TAG_DISCOVERED)) continue; if (0 == tag->triggertagid) { tag->triggertagid = triggertagid++; zbx_db_insert_add_values(&db_insert_ttags, tag->triggertagid, trigger->triggerid, tag->tag, tag->value); } else if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_UPDATE)) { const char *d = ""; zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "update trigger_tag set "); if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_UPDATE_TAG)) { value_esc = DBdyn_escape_string(tag->tag); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "tag='%s'", value_esc); zbx_free(value_esc); d = ","; } if (0 != (tag->flags & ZBX_FLAG_LLD_TAG_UPDATE_VALUE)) { value_esc = DBdyn_escape_string(tag->value); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%svalue='%s'", d, value_esc); zbx_free(value_esc); } zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " where triggertagid=" ZBX_FS_UI64 ";\n", tag->triggertagid); } } } zbx_vector_ptr_sort(&upd_functions, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC); for (i = 0; i < upd_functions.values_num; i++) { const char *d = ""; function = (zbx_lld_function_t *)upd_functions.values[i]; zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "update functions set "); if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_UPDATE_ITEMID)) { zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "itemid=" ZBX_FS_UI64, function->itemid); d = ","; } if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_UPDATE_FUNCTION)) { function_esc = DBdyn_escape_string(function->function); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%sname='%s'", d, function_esc); zbx_free(function_esc); d = ","; } if (0 != (function->flags & ZBX_FLAG_LLD_FUNCTION_UPDATE_PARAMETER)) { parameter_esc = DBdyn_escape_string(function->parameter); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%sparameter='%s'", d, parameter_esc); zbx_free(parameter_esc); } zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " where functionid=" ZBX_FS_UI64 ";\n", function->functionid); } if (0 != del_functionids.values_num) { zbx_vector_uint64_sort(&del_functionids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "delete from functions where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "functionid", del_functionids.values, del_functionids.values_num); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";\n"); } if (0 != del_triggerdepids.values_num) { zbx_vector_uint64_sort(&del_triggerdepids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "delete from trigger_depends where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "triggerdepid", del_triggerdepids.values, del_triggerdepids.values_num); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";\n"); } if (0 != del_triggertagids.values_num) { zbx_vector_uint64_sort(&del_triggertagids, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "delete from trigger_tag where"); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "triggertagid", del_triggertagids.values, del_triggertagids.values_num); zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";\n"); } if (0 != upd_triggers || 0 != upd_functions.values_num || 0 != del_functionids.values_num || 0 != del_triggerdepids.values_num || 0 != upd_tags || 0 != del_triggertagids.values_num) { DBend_multiple_update(&sql, &sql_alloc, &sql_offset); DBexecute("%s", sql); zbx_free(sql); } if (0 != new_triggers) { zbx_db_insert_execute(&db_insert); zbx_db_insert_clean(&db_insert); zbx_db_insert_execute(&db_insert_tdiscovery); zbx_db_insert_clean(&db_insert_tdiscovery); } if (0 != new_functions) { zbx_db_insert_execute(&db_insert_tfunctions); zbx_db_insert_clean(&db_insert_tfunctions); } if (0 != new_dependencies) { zbx_db_insert_execute(&db_insert_tdepends); zbx_db_insert_clean(&db_insert_tdepends); } if (0 != new_tags) { zbx_db_insert_execute(&db_insert_ttags); zbx_db_insert_clean(&db_insert_ttags); } DBcommit(); out: zbx_vector_uint64_destroy(&trigger_protoids); zbx_vector_uint64_destroy(&del_triggertagids); zbx_vector_uint64_destroy(&del_triggerdepids); zbx_vector_uint64_destroy(&del_functionids); zbx_vector_ptr_destroy(&upd_functions); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); return ret; } /* hash/comparison functions to support cache/vector lookups by trigger reference */ static zbx_hash_t zbx_lld_trigger_ref_hash_func(const void *data) { zbx_hash_t hash; const zbx_lld_trigger_node_t *trigger_node = (const zbx_lld_trigger_node_t *)data; void *ptr = NULL; hash = ZBX_DEFAULT_UINT64_HASH_ALGO(&trigger_node->trigger_ref.triggerid, sizeof(trigger_node->trigger_ref.triggerid), ZBX_DEFAULT_HASH_SEED); if (0 == trigger_node->trigger_ref.triggerid) ptr = trigger_node->trigger_ref.trigger; return ZBX_DEFAULT_PTR_HASH_ALGO(&ptr, sizeof(trigger_node->trigger_ref.trigger), hash); } static int zbx_lld_trigger_ref_compare_func(const void *d1, const void *d2) { const zbx_lld_trigger_node_t *n1 = (const zbx_lld_trigger_node_t *)d1; const zbx_lld_trigger_node_t *n2 = (const zbx_lld_trigger_node_t *)d2; ZBX_RETURN_IF_NOT_EQUAL(n1->trigger_ref.triggerid, n2->trigger_ref.triggerid); /* Don't check pointer if id matches. If the reference was loaded from database it will not have pointer. */ if (0 != n1->trigger_ref.triggerid) return 0; ZBX_RETURN_IF_NOT_EQUAL(n1->trigger_ref.trigger, n2->trigger_ref.trigger); return 0; } /* comparison function to determine trigger dependency validation order */ static int zbx_lld_trigger_node_compare_func(const void *d1, const void *d2) { const zbx_lld_trigger_node_t *n1 = *(const zbx_lld_trigger_node_t **)d1; const zbx_lld_trigger_node_t *n2 = *(const zbx_lld_trigger_node_t **)d2; /* sort in ascending order, but ensure that existing triggers are first */ if (0 != n1->trigger_ref.triggerid && 0 == n2->trigger_ref.triggerid) return -1; /* give priority to nodes with less parents */ ZBX_RETURN_IF_NOT_EQUAL(n1->parents, n2->parents); /* compare ids */ ZBX_RETURN_IF_NOT_EQUAL(n1->trigger_ref.triggerid, n2->trigger_ref.triggerid); /* Don't check pointer if id matches. If the reference was loaded from database it will not have pointer. */ if (0 != n1->trigger_ref.triggerid) return 0; ZBX_RETURN_IF_NOT_EQUAL(n1->trigger_ref.trigger, n2->trigger_ref.trigger); return 0; } /****************************************************************************** * * * Function: lld_trigger_cache_append * * * * Purpose: adds a node to trigger cache * * * * Parameters: cache - [IN] the trigger cache * * triggerid - [IN] the trigger id * * trigger - [IN] the trigger data for new triggers * * * * Return value: the added node * * * ******************************************************************************/ static zbx_lld_trigger_node_t *lld_trigger_cache_append(zbx_hashset_t *cache, zbx_uint64_t triggerid, zbx_lld_trigger_t *trigger) { zbx_lld_trigger_node_t node_local; node_local.trigger_ref.triggerid = triggerid; node_local.trigger_ref.trigger = trigger; node_local.trigger_ref.flags = 0; node_local.iter_num = 0; node_local.parents = 0; zbx_vector_ptr_create(&node_local.dependencies); return (zbx_lld_trigger_node_t *)zbx_hashset_insert(cache, &node_local, sizeof(node_local)); } /****************************************************************************** * * * Function: lld_trigger_cache_add_trigger_node * * * * Purpose: add trigger and all triggers related to it to trigger dependency * * validation cache. * * * * Parameters: cache - [IN] the trigger cache * * trigger - [IN] the trigger to add * * triggerids_up - [OUT] identifiers of generic trigger * * dependents * * triggerids_down - [OUT] identifiers of generic trigger * * dependencies * * * ******************************************************************************/ static void lld_trigger_cache_add_trigger_node(zbx_hashset_t *cache, zbx_lld_trigger_t *trigger, zbx_vector_uint64_t *triggerids_up, zbx_vector_uint64_t *triggerids_down) { zbx_lld_trigger_ref_t *trigger_ref; zbx_lld_trigger_node_t *trigger_node, trigger_node_local; zbx_lld_dependency_t *dependency; int i; trigger_node_local.trigger_ref.triggerid = trigger->triggerid; trigger_node_local.trigger_ref.trigger = trigger; if (NULL != zbx_hashset_search(cache, &trigger_node_local)) return; trigger_node = lld_trigger_cache_append(cache, trigger->triggerid, trigger); for (i = 0; i < trigger->dependencies.values_num; i++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[i]; if (0 == (dependency->flags & ZBX_FLAG_LLD_DEPENDENCY_DISCOVERED)) continue; trigger_ref = (zbx_lld_trigger_ref_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_ref_t)); trigger_ref->triggerid = dependency->triggerid_up; trigger_ref->trigger = dependency->trigger_up; trigger_ref->flags = (0 == dependency->triggerdepid ? ZBX_LLD_TRIGGER_DEPENDENCY_NEW : ZBX_LLD_TRIGGER_DEPENDENCY_NORMAL); zbx_vector_ptr_append(&trigger_node->dependencies, trigger_ref); if (NULL == trigger_ref->trigger) { trigger_node_local.trigger_ref.triggerid = trigger_ref->triggerid; trigger_node_local.trigger_ref.trigger = NULL; if (NULL == zbx_hashset_search(cache, &trigger_node_local)) { zbx_vector_uint64_append(triggerids_up, trigger_ref->triggerid); zbx_vector_uint64_append(triggerids_down, trigger_ref->triggerid); lld_trigger_cache_append(cache, trigger_ref->triggerid, NULL); } } } if (0 != trigger->triggerid) zbx_vector_uint64_append(triggerids_up, trigger->triggerid); for (i = 0; i < trigger->dependents.values_num; i++) { lld_trigger_cache_add_trigger_node(cache, (zbx_lld_trigger_t *)trigger->dependents.values[i], triggerids_up, triggerids_down); } for (i = 0; i < trigger->dependencies.values_num; i++) { dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[i]; if (NULL != dependency->trigger_up) { lld_trigger_cache_add_trigger_node(cache, dependency->trigger_up, triggerids_up, triggerids_down); } } } /****************************************************************************** * * * Function: lld_trigger_cache_init * * * * Purpose: initializes trigger cache used to perform trigger dependency * * validation * * * * Parameters: cache - [IN] the trigger cache * * triggers - [IN] the discovered triggers * * * * Comments: Triggers with new dependencies and.all triggers related to them * * are added to cache. * * * ******************************************************************************/ static void lld_trigger_cache_init(zbx_hashset_t *cache, zbx_vector_ptr_t *triggers) { zbx_vector_uint64_t triggerids_up, triggerids_down; int i, j; char *sql = NULL; size_t sql_alloc = 0, sql_offset; DB_RESULT result; DB_ROW row; zbx_lld_trigger_ref_t *trigger_ref; zbx_lld_trigger_node_t *trigger_node, trigger_node_local; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_hashset_create(cache, triggers->values_num, zbx_lld_trigger_ref_hash_func, zbx_lld_trigger_ref_compare_func); zbx_vector_uint64_create(&triggerids_down); zbx_vector_uint64_create(&triggerids_up); /* add all triggers with new dependencies to trigger cache */ for (i = 0; i < triggers->values_num; i++) { zbx_lld_trigger_t *trigger = (zbx_lld_trigger_t *)triggers->values[i]; for (j = 0; j < trigger->dependencies.values_num; j++) { zbx_lld_dependency_t *dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[j]; if (0 == dependency->triggerdepid) break; } if (j != trigger->dependencies.values_num) lld_trigger_cache_add_trigger_node(cache, trigger, &triggerids_up, &triggerids_down); } /* keep trying to load generic dependents/dependencies until there are nothing to load */ while (0 != triggerids_up.values_num || 0 != triggerids_down.values_num) { /* load dependents */ if (0 != triggerids_down.values_num) { sql_offset = 0; zbx_vector_uint64_sort(&triggerids_down, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_vector_uint64_uniq(&triggerids_down, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "select td.triggerid_down,td.triggerid_up" " from trigger_depends td" " left join triggers t" " on td.triggerid_up=t.triggerid" " where t.flags<>%d" " and", ZBX_FLAG_DISCOVERY_PROTOTYPE); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "td.triggerid_down", triggerids_down.values, triggerids_down.values_num); zbx_vector_uint64_clear(&triggerids_down); result = DBselect("%s", sql); while (NULL != (row = DBfetch(result))) { int new_node = 0; zbx_lld_trigger_node_t *trigger_node_up; ZBX_STR2UINT64(trigger_node_local.trigger_ref.triggerid, row[1]); if (NULL == (trigger_node_up = (zbx_lld_trigger_node_t *)zbx_hashset_search(cache, &trigger_node_local))) { trigger_node_up = lld_trigger_cache_append(cache, trigger_node_local.trigger_ref.triggerid, NULL); new_node = 1; } ZBX_STR2UINT64(trigger_node_local.trigger_ref.triggerid, row[0]); if (NULL == (trigger_node = (zbx_lld_trigger_node_t *)zbx_hashset_search(cache, &trigger_node_local))) { THIS_SHOULD_NEVER_HAPPEN; continue; } /* check if the dependency is not already registered in cache */ for (i = 0; i < trigger_node->dependencies.values_num; i++) { trigger_ref = (zbx_lld_trigger_ref_t *)trigger_node->dependencies.values[i]; /* references to generic triggers will always have valid id value */ if (trigger_ref->triggerid == trigger_node_up->trigger_ref.triggerid) break; } /* if the dependency was not found - add it */ if (i == trigger_node->dependencies.values_num) { trigger_ref = (zbx_lld_trigger_ref_t *)zbx_malloc(NULL, sizeof(zbx_lld_trigger_ref_t)); trigger_ref->triggerid = trigger_node_up->trigger_ref.triggerid; trigger_ref->trigger = NULL; trigger_ref->flags = ZBX_LLD_TRIGGER_DEPENDENCY_NORMAL; zbx_vector_ptr_append(&trigger_node->dependencies, trigger_ref); trigger_node_up->parents++; } if (1 == new_node) { /* if the trigger was added to cache, we must check its dependencies */ zbx_vector_uint64_append(&triggerids_up, trigger_node_up->trigger_ref.triggerid); zbx_vector_uint64_append(&triggerids_down, trigger_node_up->trigger_ref.triggerid); } } DBfree_result(result); } /* load dependencies */ if (0 != triggerids_up.values_num) { sql_offset = 0; zbx_vector_uint64_sort(&triggerids_up, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_vector_uint64_uniq(&triggerids_up, ZBX_DEFAULT_UINT64_COMPARE_FUNC); zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "select td.triggerid_down" " from trigger_depends td" " left join triggers t" " on t.triggerid=td.triggerid_down" " where t.flags<>%d" " and", ZBX_FLAG_DISCOVERY_PROTOTYPE); DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "td.triggerid_up", triggerids_up.values, triggerids_up.values_num); zbx_vector_uint64_clear(&triggerids_up); result = DBselect("%s", sql); while (NULL != (row = DBfetch(result))) { ZBX_STR2UINT64(trigger_node_local.trigger_ref.triggerid, row[0]); if (NULL != zbx_hashset_search(cache, &trigger_node_local)) continue; lld_trigger_cache_append(cache, trigger_node_local.trigger_ref.triggerid, NULL); zbx_vector_uint64_append(&triggerids_up, trigger_node_local.trigger_ref.triggerid); zbx_vector_uint64_append(&triggerids_down, trigger_node_local.trigger_ref.triggerid); } DBfree_result(result); } } zbx_free(sql); zbx_vector_uint64_destroy(&triggerids_up); zbx_vector_uint64_destroy(&triggerids_down); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } /****************************************************************************** * * * Function: zbx_trigger_cache_clean * * * * Purpose: releases resources allocated by trigger cache * * validation * * * * Parameters: cache - [IN] the trigger cache * * * ******************************************************************************/ static void zbx_trigger_cache_clean(zbx_hashset_t *cache) { zbx_hashset_iter_t iter; zbx_lld_trigger_node_t *trigger_node; zbx_hashset_iter_reset(cache, &iter); while (NULL != (trigger_node = (zbx_lld_trigger_node_t *)zbx_hashset_iter_next(&iter))) { zbx_vector_ptr_clear_ext(&trigger_node->dependencies, zbx_ptr_free); zbx_vector_ptr_destroy(&trigger_node->dependencies); } zbx_hashset_destroy(cache); } /****************************************************************************** * * * Function: lld_trigger_dependency_delete * * * * Purpose: removes trigger dependency * * * * Parameters: from - [IN] the reference to dependent trigger * * to - [IN] the reference to trigger the from depends on * * error - [OUT] the error message * * * * Comments: If possible (the dependency loop was introduced by discovered * * dependencies) the last dependency in the loop will be removed. * * Otherwise (the triggers in database already had dependency loop) * * the last dependency in the loop will be marked as removed, * * however the dependency in database will be left intact. * * * ******************************************************************************/ static void lld_trigger_dependency_delete(zbx_lld_trigger_ref_t *from, zbx_lld_trigger_ref_t *to, char **error) { zbx_lld_trigger_t *trigger; int i; char *trigger_desc; if (ZBX_LLD_TRIGGER_DEPENDENCY_NORMAL == to->flags) { /* When old dependency loop has been detected mark it as deleted to avoid */ /* infinite recursion during dependency validation, but don't really delete */ /* it because only new dependencies can be deleted. */ /* in old dependency loop there are no new triggers, so all involved */ /* triggers have valid identifiers */ zabbix_log(LOG_LEVEL_CRIT, "existing recursive dependency loop detected for trigger \"" ZBX_FS_UI64 "\"", to->triggerid); return; } trigger = from->trigger; /* remove the dependency */ for (i = 0; i < trigger->dependencies.values_num; i++) { zbx_lld_dependency_t *dependency = (zbx_lld_dependency_t *)trigger->dependencies.values[i]; if ((NULL != dependency->trigger_up && dependency->trigger_up == to->trigger) || (0 != dependency->triggerid_up && dependency->triggerid_up == to->triggerid)) { zbx_free(dependency); zbx_vector_ptr_remove(&trigger->dependencies, i); break; } } if (0 != from->triggerid) trigger_desc = zbx_dsprintf(NULL, ZBX_FS_UI64, from->triggerid); else trigger_desc = zbx_strdup(NULL, from->trigger->description); *error = zbx_strdcatf(*error, "Cannot create all trigger \"%s\" dependencies:" " recursion too deep.\n", trigger_desc); zbx_free(trigger_desc); } /****************************************************************************** * * * Function: lld_trigger_dependencies_iter * * * * Purpose: iterates through trigger dependencies to find dependency loops * * * * Parameters: cache - [IN] the trigger cache * * triggers - [IN] the discovered triggers * * trigger_node - [IN] the trigger to check * * iter - [IN] the dependency iterator * * level - [IN] the dependency level * * error - [OUT] the error message * * * * Return value: SUCCEED - the trigger's dependency chain in valid * * FAIL - a dependency loop was detected * * * * Comments: If the validation fails the offending dependency is removed. * * * ******************************************************************************/ static int lld_trigger_dependencies_iter(zbx_hashset_t *cache, zbx_vector_ptr_t *triggers, zbx_lld_trigger_node_t *trigger_node, zbx_lld_trigger_node_iter_t *iter, int level, char **error) { int i; zbx_lld_trigger_ref_t *trigger_ref; zbx_lld_trigger_node_t *trigger_node_up; zbx_lld_trigger_node_iter_t child_iter, *piter; if (trigger_node->iter_num == iter->iter_num || ZBX_TRIGGER_DEPENDENCY_LEVELS_MAX < level) { /* dependency loop detected, resolve it by deleting corresponding dependency */ lld_trigger_dependency_delete(iter->ref_from, iter->ref_to, error); /* mark the dependency as removed */ iter->ref_to->flags = ZBX_LLD_TRIGGER_DEPENDENCY_DELETE; return FAIL; } trigger_node->iter_num = iter->iter_num; for (i = 0; i < trigger_node->dependencies.values_num; i++) { trigger_ref = (zbx_lld_trigger_ref_t *)trigger_node->dependencies.values[i]; /* skip dependencies marked as deleted */ if (ZBX_LLD_TRIGGER_DEPENDENCY_DELETE == trigger_ref->flags) continue; if (NULL == (trigger_node_up = (zbx_lld_trigger_node_t *)zbx_hashset_search(cache, trigger_ref))) { THIS_SHOULD_NEVER_HAPPEN; continue; } /* Remember last dependency that could be cut. */ /* It should be either a last new dependency or just a last dependency */ /* if no new dependencies were encountered. */ if (ZBX_LLD_TRIGGER_DEPENDENCY_NEW == trigger_ref->flags || NULL == iter->ref_to || ZBX_LLD_TRIGGER_DEPENDENCY_NORMAL == iter->ref_to->flags) { child_iter.ref_from = &trigger_node->trigger_ref; child_iter.ref_to = trigger_ref; child_iter.iter_num = iter->iter_num; piter = &child_iter; } else piter = iter; if (FAIL == lld_trigger_dependencies_iter(cache, triggers, trigger_node_up, piter, level + 1, error)) return FAIL; } trigger_node->iter_num = 0; return SUCCEED; } /****************************************************************************** * * * Function: lld_trigger_dependencies_validate * * * * Purpose: validate discovered trigger dependencies * * * * Parameters: triggers - [IN] the discovered triggers * * error - [OUT] the error message * * triggers - [IN] the discovered triggers * * trigger - [IN] the trigger to check * * iter - [IN] the dependency iterator * * level - [IN] the dependency level * * * * Comments: During validation the dependency loops will be resolved by * * removing offending dependencies. * * * ******************************************************************************/ static void lld_trigger_dependencies_validate(zbx_vector_ptr_t *triggers, char **error) { zbx_hashset_t cache; zbx_hashset_iter_t iter; zbx_lld_trigger_node_t *trigger_node, *trigger_node_up; zbx_lld_trigger_node_iter_t node_iter = {0}; zbx_vector_ptr_t nodes; int i; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); lld_trigger_cache_init(&cache, triggers); /* Perform dependency validation in the order of trigger ids and starting with parentless triggers. */ /* This will give some consistency in choosing what dependencies should be deleted in the case of */ /* recursion. */ zbx_vector_ptr_create(&nodes); zbx_vector_ptr_reserve(&nodes, cache.num_data); zbx_hashset_iter_reset(&cache, &iter); while (NULL != (trigger_node = (zbx_lld_trigger_node_t *)zbx_hashset_iter_next(&iter))) { for (i = 0; i < trigger_node->dependencies.values_num; i++) { if (NULL == (trigger_node_up = (zbx_lld_trigger_node_t *)zbx_hashset_search(&cache, trigger_node->dependencies.values[i]))) { THIS_SHOULD_NEVER_HAPPEN; continue; } trigger_node_up->parents++; } zbx_vector_ptr_append(&nodes, trigger_node); } zbx_vector_ptr_sort(&nodes, zbx_lld_trigger_node_compare_func); for (i = 0; i < nodes.values_num; i++) { if (NULL == (trigger_node = (zbx_lld_trigger_node_t *)zbx_hashset_search(&cache, (zbx_lld_trigger_node_t *)nodes.values[i]))) { THIS_SHOULD_NEVER_HAPPEN; continue; } /* If dependency iterator returns false it means that dependency loop was detected */ /* (and resolved). In this case we have to validate dependencies for this trigger */ /* again. */ do { node_iter.iter_num++; node_iter.ref_from = NULL; node_iter.ref_to = NULL; } while (SUCCEED != lld_trigger_dependencies_iter(&cache, triggers, trigger_node, &node_iter, 0, error)); } zbx_vector_ptr_destroy(&nodes); zbx_trigger_cache_clean(&cache); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); } static void get_trigger_info(const void *object, zbx_uint64_t *id, int *discovery_flag, int *lastcheck, int *ts_delete) { zbx_lld_trigger_t *trigger; trigger = (zbx_lld_trigger_t *)object; *id = trigger->triggerid; *discovery_flag = trigger->flags & ZBX_FLAG_LLD_TRIGGER_DISCOVERED; *lastcheck = trigger->lastcheck; *ts_delete = trigger->ts_delete; } /****************************************************************************** * * * Function: lld_update_triggers * * * * Purpose: add or update triggers for discovered items * * * * Return value: SUCCEED - if triggers were successfully added/updated or * * adding/updating was not necessary * * FAIL - triggers cannot be added/updated * * * ******************************************************************************/ int lld_update_triggers(zbx_uint64_t hostid, zbx_uint64_t lld_ruleid, const zbx_vector_ptr_t *lld_rows, const zbx_vector_ptr_t *lld_macro_paths, char **error, int lifetime, int lastcheck) { zbx_vector_ptr_t trigger_prototypes; zbx_vector_ptr_t triggers; zbx_vector_ptr_t items; zbx_lld_trigger_t *trigger; zbx_lld_trigger_prototype_t *trigger_prototype; int ret = SUCCEED, i; zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__); zbx_vector_ptr_create(&trigger_prototypes); lld_trigger_prototypes_get(lld_ruleid, &trigger_prototypes); if (0 == trigger_prototypes.values_num) goto out; zbx_vector_ptr_create(&triggers); /* list of triggers which were created or will be created or */ /* updated by the trigger prototype */ zbx_vector_ptr_create(&items); /* list of items which are related to the trigger prototypes */ lld_triggers_get(&trigger_prototypes, &triggers); lld_functions_get(&trigger_prototypes, &triggers); lld_dependencies_get(&trigger_prototypes, &triggers); lld_tags_get(&trigger_prototypes, &triggers); lld_items_get(&trigger_prototypes, &items); /* simplifying trigger expressions */ for (i = 0; i < trigger_prototypes.values_num; i++) { trigger_prototype = (zbx_lld_trigger_prototype_t *)trigger_prototypes.values[i]; lld_expressions_simplify(&trigger_prototype->expression, &trigger_prototype->recovery_expression, &trigger_prototype->functions); } for (i = 0; i < triggers.values_num; i++) { trigger = (zbx_lld_trigger_t *)triggers.values[i]; lld_expressions_simplify(&trigger->expression, &trigger->recovery_expression, &trigger->functions); } /* making triggers */ lld_triggers_make(&trigger_prototypes, &triggers, &items, lld_rows, lld_macro_paths, error); lld_triggers_validate(hostid, &triggers, error); lld_trigger_dependencies_make(&trigger_prototypes, &triggers, lld_rows, error); lld_trigger_dependencies_validate(&triggers, error); lld_trigger_tags_make(&trigger_prototypes, &triggers, lld_rows, lld_macro_paths); lld_trigger_tags_validate(&triggers, error); ret = lld_triggers_save(hostid, &trigger_prototypes, &triggers); lld_remove_lost_objects("trigger_discovery", "triggerid", &triggers, lifetime, lastcheck, DBdelete_triggers, get_trigger_info); /* cleaning */ zbx_vector_ptr_clear_ext(&items, (zbx_mem_free_func_t)lld_item_free); zbx_vector_ptr_clear_ext(&triggers, (zbx_mem_free_func_t)lld_trigger_free); zbx_vector_ptr_destroy(&items); zbx_vector_ptr_destroy(&triggers); out: zbx_vector_ptr_clear_ext(&trigger_prototypes, (zbx_mem_free_func_t)lld_trigger_prototype_free); zbx_vector_ptr_destroy(&trigger_prototypes); zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __func__); return ret; }