/******************************************************************************
* *
* Function: lld_graphs_validate *
* *
* Parameters: graphs - [IN] sorted list of graphs *
* *
******************************************************************************/
static void lld_graphs_validate(zbx_uint64_t hostid, zbx_vector_ptr_t *graphs, char **error)
{
const char *__function_name = "lld_graphs_validate";
int i, j;
zbx_lld_graph_t *graph, *graph_b;
zbx_vector_uint64_t graphids;
zbx_vector_str_t names;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
zbx_vector_uint64_create(&graphids);
zbx_vector_str_create(&names); /* list of graph names */
/* checking a validity of the fields */
for (i = 0; i < graphs->values_num; i++)
{
graph = (zbx_lld_graph_t *)graphs->values[i];
lld_validate_graph_field(graph, &graph->name, &graph->name_orig,
ZBX_FLAG_LLD_GRAPH_UPDATE_NAME, GRAPH_NAME_LEN, error);
}
/* checking duplicated graph names */
for (i = 0; i < graphs->values_num; i++)
{
graph = (zbx_lld_graph_t *)graphs->values[i];
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED))
continue;
/* only new graphs or graphs with changed name will be validated */
if (0 != graph->graphid && 0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_UPDATE_NAME))
continue;
for (j = 0; j < graphs->values_num; j++)
{
graph_b = (zbx_lld_graph_t *)graphs->values[j];
if (0 == (graph_b->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED) || i == j)
continue;
if (0 != strcmp(graph->name, graph_b->name))
continue;
*error = zbx_strdcatf(*error, "Cannot %s graph:"
" graph with the same name \"%s\" already exists.\n",
(0 != graph->graphid ? "update" : "create"), graph->name);
if (0 != graph->graphid)
{
lld_field_str_rollback(&graph->name, &graph->name_orig, &graph->flags,
ZBX_FLAG_LLD_GRAPH_UPDATE_NAME);
}
else
graph->flags &= ~ZBX_FLAG_LLD_GRAPH_DISCOVERED;
break;
}
}
/* checking duplicated graphs in DB */
for (i = 0; i < graphs->values_num; i++)
{
graph = (zbx_lld_graph_t *)graphs->values[i];
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED))
continue;
if (0 != graph->graphid)
{
zbx_vector_uint64_append(&graphids, graph->graphid);
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_UPDATE_NAME))
continue;
}
zbx_vector_str_append(&names, graph->name);
}
if (0 != names.values_num)
{
DB_RESULT result;
DB_ROW row;
char *sql = NULL;
size_t sql_alloc = 256, sql_offset = 0;
sql = zbx_malloc(sql, sql_alloc);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select g.name"
" from graphs g,graphs_items gi,items i"
" where g.graphid=gi.graphid"
" and gi.itemid=i.itemid"
" and i.hostid=" ZBX_FS_UI64
" and",
hostid);
DBadd_str_condition_alloc(&sql, &sql_alloc, &sql_offset, "g.name",
(const char **)names.values, names.values_num);
if (0 != graphids.values_num)
{
zbx_vector_uint64_sort(&graphids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, " and not");
DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "g.graphid",
graphids.values, graphids.values_num);
}
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result)))
{
for (i = 0; i < graphs->values_num; i++)
{
graph = (zbx_lld_graph_t *)graphs->values[i];
if (0 == (graph->flags & ZBX_FLAG_LLD_GRAPH_DISCOVERED))
continue;
if (0 == strcmp(graph->name, row[0]))
{
*error = zbx_strdcatf(*error, "Cannot %s graph:"
" graph with the same name \"%s\" already exists.\n",
(0 != graph->graphid ? "update" : "create"), graph->name);
if (0 != graph->graphid)
{
lld_field_str_rollback(&graph->name, &graph->name_orig, &graph->flags,
ZBX_FLAG_LLD_GRAPH_UPDATE_NAME);
}
else
graph->flags &= ~ZBX_FLAG_LLD_GRAPH_DISCOVERED;
continue;
}
}
}
DBfree_result(result);
zbx_free(sql);
}
zbx_vector_str_destroy(&names);
zbx_vector_uint64_destroy(&graphids);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* 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)
{
const char *__function_name = "lld_triggers_validate";
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()", __function_name);
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);
}
/* 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 = zbx_malloc(sql, sql_alloc);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,
"select distinct t.triggerid,t.description,t.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_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->comments = NULL;
db_trigger->comments_orig = NULL;
db_trigger->flags = ZBX_FLAG_LLD_TRIGGER_UNSET;
zbx_vector_ptr_create(&db_trigger->functions);
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(0, NULL, &db_triggers);
for (i = 0; i < db_triggers.values_num; i++)
{
db_trigger = (zbx_lld_trigger_t *)db_triggers.values[i];
lld_expression_simplify(&db_trigger->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);
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_clean(&db_triggers, (zbx_mem_free_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()", __function_name);
}
