Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/zabbix/zabbix.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/zbxhistory.h3
-rw-r--r--include/zbxserver.h2
-rw-r--r--src/libs/zbxhistory/history.c30
-rw-r--r--src/libs/zbxserver/evalfunc2.c119
-rw-r--r--src/libs/zbxserver/expression.c13
-rw-r--r--tests/libs/zbxhistory/Makefile.am2
-rwxr-xr-xtests/libs/zbxserver/Makefile.am2
-rw-r--r--tests/libs/zbxserver/evaluate_function.c38
-rw-r--r--tests/libs/zbxserver/evaluate_function.yaml12
9 files changed, 131 insertions, 90 deletions
diff --git a/include/zbxhistory.h b/include/zbxhistory.h
index 2fe5f779d70..788864aa1e5 100644
--- a/include/zbxhistory.h
+++ b/include/zbxhistory.h
@@ -20,6 +20,8 @@
#ifndef ZABBIX_ZBXHISTORY_H
#define ZABBIX_ZBXHISTORY_H
+#include "zbxvariant.h"
+
/* the item history value */
typedef struct
{
@@ -40,6 +42,7 @@ int zbx_history_record_compare_desc_func(const zbx_history_record_t *d1, const z
void zbx_history_value2str(char *buffer, size_t size, const history_value_t *value, int value_type);
char *zbx_history_value2str_dyn(const history_value_t *value, int value_type);
void zbx_history_value_print(char *buffer, size_t size, const history_value_t *value, int value_type);
+void zbx_history_value2variant(const history_value_t *value, unsigned char value_type, zbx_variant_t *var);
/* In most cases zbx_history_record_vector_destroy() function should be used to free the */
/* value vector filled by zbx_vc_get_value* functions. This define simply better */
diff --git a/include/zbxserver.h b/include/zbxserver.h
index 8076dddfa67..033a7a95cd8 100644
--- a/include/zbxserver.h
+++ b/include/zbxserver.h
@@ -62,7 +62,7 @@ void get_functionids(zbx_vector_uint64_t *functionids, const char *expression);
int evaluate_function(char **value, DC_ITEM *item, const char *function, const char *parameter,
const zbx_timespec_t *ts, char **error);
-int evaluate_function2(char **value, DC_ITEM *item, const char *function, const char *parameter,
+int evaluate_function2(zbx_variant_t *value, DC_ITEM *item, const char *function, const char *parameter,
const zbx_timespec_t *ts, char **error);
diff --git a/src/libs/zbxhistory/history.c b/src/libs/zbxhistory/history.c
index 8215ea49e18..54bc95ba1a9 100644
--- a/src/libs/zbxhistory/history.c
+++ b/src/libs/zbxhistory/history.c
@@ -426,3 +426,33 @@ int zbx_history_record_compare_desc_func(const zbx_history_record_t *d1, const z
return d2->timestamp.sec - d1->timestamp.sec;
}
+/******************************************************************************
+ * *
+ * Function: zbx_history_value2variant *
+ * *
+ * Purpose: converts history value to variant value *
+ * *
+ * Parameters: value - [IN] the value to convert *
+ * value_type - [IN] the history value type *
+ * var - [IN] the output value *
+ * *
+ ******************************************************************************/
+void zbx_history_value2variant(const history_value_t *value, unsigned char value_type, zbx_variant_t *var)
+{
+ switch (value_type)
+ {
+ case ITEM_VALUE_TYPE_FLOAT:
+ zbx_variant_set_dbl(var, value->dbl);
+ break;
+ case ITEM_VALUE_TYPE_UINT64:
+ zbx_variant_set_ui64(var, value->ui64);
+ break;
+ case ITEM_VALUE_TYPE_STR:
+ case ITEM_VALUE_TYPE_TEXT:
+ zbx_variant_set_str(var, zbx_strdup(NULL, value->str));
+ break;
+ case ITEM_VALUE_TYPE_LOG:
+ zbx_variant_set_str(var, zbx_strdup(NULL, value->log->value));
+ }
+}
+
diff --git a/src/libs/zbxserver/evalfunc2.c b/src/libs/zbxserver/evalfunc2.c
index 9ed2cf03671..d8d7aced96a 100644
--- a/src/libs/zbxserver/evalfunc2.c
+++ b/src/libs/zbxserver/evalfunc2.c
@@ -307,7 +307,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_LOGEVENTID(char **value, DC_ITEM *item, const char *parameters,
+static int evaluate_LOGEVENTID(zbx_variant_t *value, DC_ITEM *item, const char *parameters,
const zbx_timespec_t *ts, char **error)
{
char *arg1 = NULL;
@@ -362,9 +362,9 @@ static int evaluate_LOGEVENTID(char **value, DC_ITEM *item, const char *paramete
else
{
if (ZBX_REGEXP_MATCH == regexp_ret)
- *value = zbx_strdup(*value, "1");
+ zbx_variant_set_dbl(value, 1);
else if (ZBX_REGEXP_NO_MATCH == regexp_ret)
- *value = zbx_strdup(*value, "0");
+ zbx_variant_set_dbl(value, 0);
ret = SUCCEED;
}
@@ -400,7 +400,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_LOGSOURCE(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_LOGSOURCE(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
char *arg1 = NULL;
@@ -446,11 +446,11 @@ static int evaluate_LOGSOURCE(char **value, DC_ITEM *item, const char *parameter
switch (regexp_match_ex(&regexps, vc_value.value.log->source, arg1, ZBX_CASE_SENSITIVE))
{
case ZBX_REGEXP_MATCH:
- *value = zbx_strdup(*value, "1");
+ zbx_variant_set_dbl(value, 1);
ret = SUCCEED;
break;
case ZBX_REGEXP_NO_MATCH:
- *value = zbx_strdup(*value, "0");
+ zbx_variant_set_dbl(value, 0);
ret = SUCCEED;
break;
case FAIL:
@@ -487,7 +487,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_LOGSEVERITY(char **value, DC_ITEM *item, const zbx_timespec_t *ts, char **error)
+static int evaluate_LOGSEVERITY(zbx_variant_t *value, DC_ITEM *item, const zbx_timespec_t *ts, char **error)
{
int ret = FAIL;
zbx_history_record_t vc_value;
@@ -502,9 +502,7 @@ static int evaluate_LOGSEVERITY(char **value, DC_ITEM *item, const zbx_timespec_
if (SUCCEED == zbx_vc_get_value(item->itemid, item->value_type, ts, &vc_value))
{
- size_t value_alloc = 0, value_offset = 0;
-
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, "%d", vc_value.value.log->severity);
+ zbx_variant_set_dbl(value, vc_value.value.log->severity);
zbx_history_record_clear(&vc_value, item->value_type);
ret = SUCCEED;
@@ -652,7 +650,7 @@ static void count_one_str(int *count, int op, const char *value, const char *pat
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_COUNT(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, int limit,
+static int evaluate_COUNT(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, int limit,
char **error)
{
int arg1, op = OP_UNKNOWN, numeric_search, nparams, count = 0, i, ret = FAIL;
@@ -664,7 +662,6 @@ static int evaluate_COUNT(char **value, DC_ITEM *item, const char *parameters, c
zbx_vector_ptr_t regexps;
zbx_vector_history_record_t values;
zbx_timespec_t ts_end = *ts;
- size_t value_alloc = 0, value_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
@@ -679,8 +676,7 @@ static int evaluate_COUNT(char **value, DC_ITEM *item, const char *parameters, c
goto out;
}
- if (SUCCEED != get_function_parameter_hist_range(ts->sec, parameters, 1, &arg1, &arg1_type, &time_shift) ||
- ZBX_VALUE_NONE == arg1_type)
+ if (SUCCEED != get_function_parameter_hist_range(ts->sec, parameters, 1, &arg1, &arg1_type, &time_shift))
{
*error = zbx_strdup(*error, "invalid second parameter");
goto out;
@@ -832,6 +828,9 @@ static int evaluate_COUNT(char **value, DC_ITEM *item, const char *parameters, c
case ZBX_VALUE_NVALUES:
nvalues = arg1;
break;
+ case ZBX_VALUE_NONE:
+ nvalues = 1;
+ break;
default:
THIS_SHOULD_NEVER_HAPPEN;
}
@@ -904,7 +903,7 @@ static int evaluate_COUNT(char **value, DC_ITEM *item, const char *parameters, c
count = limit;
}
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, "%d", count);
+ zbx_variant_set_dbl(value, count);
ret = SUCCEED;
out:
@@ -947,7 +946,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_SUM(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
+static int evaluate_SUM(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
{
int nparams, arg1, i, ret = FAIL, seconds = 0, nvalues = 0, time_shift;
zbx_value_type_t arg1_type;
@@ -1013,7 +1012,7 @@ static int evaluate_SUM(char **value, DC_ITEM *item, const char *parameters, con
result.ui64 += values.values[i].value.ui64;
}
- *value = zbx_history_value2str_dyn(&result, item->value_type);
+ zbx_history_value2variant(&result, item->value_type, value);
ret = SUCCEED;
out:
zbx_history_record_vector_destroy(&values, item->value_type);
@@ -1036,7 +1035,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_AVG(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
+static int evaluate_AVG(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
{
int nparams, arg1, ret = FAIL, i, seconds = 0, nvalues = 0, time_shift;
zbx_value_type_t arg1_type;
@@ -1089,7 +1088,6 @@ static int evaluate_AVG(char **value, DC_ITEM *item, const char *parameters, con
if (0 < values.values_num)
{
double avg = 0;
- size_t value_alloc = 0, value_offset = 0;
if (ITEM_VALUE_TYPE_FLOAT == item->value_type)
{
@@ -1103,7 +1101,7 @@ static int evaluate_AVG(char **value, DC_ITEM *item, const char *parameters, con
avg = avg / values.values_num;
}
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, ZBX_FS_DBL64, avg);
+ zbx_variant_set_dbl(value, avg);
ret = SUCCEED;
}
@@ -1134,7 +1132,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_LAST(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_LAST(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
int arg1 = 1, ret = FAIL, time_shift;
@@ -1161,7 +1159,7 @@ static int evaluate_LAST(char **value, DC_ITEM *item, const char *parameters, co
{
if (arg1 <= values.values_num)
{
- *value = zbx_history_value2str_dyn(&values.values[arg1 - 1].value, item->value_type);
+ zbx_history_value2variant(&values.values[arg1 - 1].value, item->value_type, value);
ret = SUCCEED;
}
else
@@ -1195,7 +1193,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_MIN(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
+static int evaluate_MIN(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
{
int nparams, arg1, i, ret = FAIL, seconds = 0, nvalues = 0, time_shift;
zbx_value_type_t arg1_type;
@@ -1266,7 +1264,7 @@ static int evaluate_MIN(char **value, DC_ITEM *item, const char *parameters, con
}
}
- *value = zbx_history_value2str_dyn(&values.values[index].value, item->value_type);
+ zbx_history_value2variant(&values.values[index].value, item->value_type, value);
ret = SUCCEED;
}
else
@@ -1295,7 +1293,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_MAX(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
+static int evaluate_MAX(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts, char **error)
{
int nparams, arg1, ret = FAIL, i, seconds = 0, nvalues = 0, time_shift;
zbx_value_type_t arg1_type;
@@ -1366,7 +1364,7 @@ static int evaluate_MAX(char **value, DC_ITEM *item, const char *parameters, con
}
}
- *value = zbx_history_value2str_dyn(&values.values[index].value, item->value_type);
+ zbx_history_value2variant(&values.values[index].value, item->value_type, value);
ret = SUCCEED;
}
@@ -1412,7 +1410,7 @@ static int __history_record_uint64_compare(const zbx_history_record_t *d1, const
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_PERCENTILE(char **value, DC_ITEM *item, const char *parameters,
+static int evaluate_PERCENTILE(zbx_variant_t *value, DC_ITEM *item, const char *parameters,
const zbx_timespec_t *ts, char **error)
{
int nparams, arg1, time_shift, ret = FAIL, seconds = 0, nvalues = 0;
@@ -1486,7 +1484,7 @@ static int evaluate_PERCENTILE(char **value, DC_ITEM *item, const char *paramete
else
index = (int)ceil(values.values_num * (percentage / 100));
- *value = zbx_history_value2str_dyn(&values.values[index - 1].value, item->value_type);
+ zbx_history_value2variant(&values.values[index - 1].value, item->value_type, value);
ret = SUCCEED;
}
@@ -1516,7 +1514,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_NODATA(char **value, DC_ITEM *item, const char *parameters, char **error)
+static int evaluate_NODATA(zbx_variant_t *value, DC_ITEM *item, const char *parameters, char **error)
{
int arg1, num, period, lazy = 1, ret = FAIL;
zbx_value_type_t arg1_type;
@@ -1570,7 +1568,7 @@ static int evaluate_NODATA(char **value, DC_ITEM *item, const char *parameters,
if (SUCCEED == zbx_vc_get_values(item->itemid, item->value_type, &values, period, 1, &ts) &&
1 == values.values_num)
{
- *value = zbx_strdup(*value, "0");
+ zbx_variant_set_dbl(value, 0);
}
else
{
@@ -1595,7 +1593,7 @@ static int evaluate_NODATA(char **value, DC_ITEM *item, const char *parameters,
goto out;
}
- *value = zbx_strdup(*value, "1");
+ zbx_variant_set_dbl(value, 1);
if (0 != item->host.proxy_hostid && 0 != lazy)
{
@@ -1628,7 +1626,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_FUZZYTIME(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_FUZZYTIME(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
int arg1, ret = FAIL;
@@ -1674,16 +1672,16 @@ static int evaluate_FUZZYTIME(char **value, DC_ITEM *item, const char *parameter
if (ITEM_VALUE_TYPE_UINT64 == item->value_type)
{
if (vc_value.value.ui64 >= fuzlow && vc_value.value.ui64 <= fuzhig)
- *value = zbx_strdup(*value, "1");
+ zbx_variant_set_dbl(value, 1);
else
- *value = zbx_strdup(*value, "0");
+ zbx_variant_set_dbl(value, 0);
}
else
{
if (vc_value.value.dbl >= fuzlow && vc_value.value.dbl <= fuzhig)
- *value = zbx_strdup(*value, "1");
+ zbx_variant_set_dbl(value, 1);
else
- *value = zbx_strdup(*value, "0");
+ zbx_variant_set_dbl(value, 0);
}
zbx_history_record_clear(&vc_value, item->value_type);
@@ -1716,12 +1714,12 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_BAND(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_BAND(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
char *last_parameters = NULL;
int nparams, ret = FAIL;
- zbx_uint64_t last_uint64, mask;
+ zbx_uint64_t mask;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
@@ -1748,10 +1746,13 @@ static int evaluate_BAND(char **value, DC_ITEM *item, const char *parameters, co
if (SUCCEED == evaluate_LAST(value, item, last_parameters, ts, error))
{
- ZBX_STR2UINT64(last_uint64, *value);
- /* 'and' bit operation cannot be larger than the source value, */
- /* so the result can just be copied in value buffer */
- zbx_snprintf(*value, strlen(*value) + 1, ZBX_FS_UI64, last_uint64 & (zbx_uint64_t)mask);
+ /* the evaluate_LAST() should return uint64 value, but just to be sure try to convert it */
+ if (SUCCEED != zbx_variant_convert(value, ZBX_VARIANT_UI64))
+ {
+ *error = zbx_strdup(*error, "invalid value type");
+ goto clean;
+ }
+ zbx_variant_set_dbl(value, value->data.ui64 & (zbx_uint64_t)mask);
ret = SUCCEED;
}
@@ -1775,7 +1776,7 @@ clean:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_FORECAST(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_FORECAST(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
char *fit_str = NULL, *mode_str = NULL;
@@ -1788,7 +1789,6 @@ static int evaluate_FORECAST(char **value, DC_ITEM *item, const char *parameters
zbx_fit_t fit;
zbx_mode_t mode;
zbx_timespec_t ts_end = *ts;
- size_t value_alloc = 0, value_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
@@ -1895,14 +1895,12 @@ static int evaluate_FORECAST(char **value, DC_ITEM *item, const char *parameters
}
}
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, ZBX_FS_DBL64, zbx_forecast(t, x,
- values.values_num, ts->sec - zero_time.sec - 1.0e-9 * (zero_time.ns + 1), time, fit, k,
- mode));
+ zbx_variant_set_dbl(value, zbx_forecast(t, x, values.values_num,
+ ts->sec - zero_time.sec - 1.0e-9 * (zero_time.ns + 1), time, fit, k, mode));
}
else
{
- zabbix_log(LOG_LEVEL_DEBUG, "no data available");
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, ZBX_FS_DBL64, ZBX_MATH_ERROR);
+ zbx_variant_set_dbl(value, ZBX_MATH_ERROR);
}
ret = SUCCEED;
@@ -1933,7 +1931,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_TIMELEFT(char **value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
+static int evaluate_TIMELEFT(zbx_variant_t *value, DC_ITEM *item, const char *parameters, const zbx_timespec_t *ts,
char **error)
{
char *fit_str = NULL;
@@ -1945,7 +1943,6 @@ static int evaluate_TIMELEFT(char **value, DC_ITEM *item, const char *parameters
zbx_timespec_t zero_time;
zbx_fit_t fit;
zbx_timespec_t ts_end = *ts;
- size_t value_alloc = 0, value_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __func__);
@@ -2043,14 +2040,12 @@ static int evaluate_TIMELEFT(char **value, DC_ITEM *item, const char *parameters
}
}
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, ZBX_FS_DBL64, zbx_timeleft(t, x,
- values.values_num, ts->sec - zero_time.sec - 1.0e-9 * (zero_time.ns + 1), threshold,
- fit, k));
+ zbx_variant_set_dbl(value, zbx_timeleft(t, x, values.values_num,
+ ts->sec - zero_time.sec - 1.0e-9 * (zero_time.ns + 1), threshold, fit, k));
}
else
{
- zabbix_log(LOG_LEVEL_DEBUG, "no data available");
- zbx_snprintf_alloc(value, &value_alloc, &value_offset, ZBX_FS_DBL64, ZBX_MATH_ERROR);
+ zbx_variant_set_dbl(value, ZBX_MATH_ERROR);
}
ret = SUCCEED;
@@ -2085,7 +2080,7 @@ out:
* FAIL - failed to evaluate function *
* *
******************************************************************************/
-static int evaluate_TREND(char **value, DC_ITEM *item, const char *func, const char *parameters,
+static int evaluate_TREND(zbx_variant_t *value, DC_ITEM *item, const char *func, const char *parameters,
const zbx_timespec_t *ts, char **error)
{
int ret = FAIL, start, end;
@@ -2148,7 +2143,7 @@ static int evaluate_TREND(char **value, DC_ITEM *item, const char *func, const c
}
if (SUCCEED == ret)
- *value = zbx_dsprintf(*value, ZBX_FS_DBL64, value_dbl);
+ zbx_variant_set_dbl(value, value_dbl);
out:
zbx_free(period);
zbx_free(period_shift);
@@ -2172,7 +2167,7 @@ out:
* FAIL - evaluation failed *
* *
******************************************************************************/
-int evaluate_function2(char **value, DC_ITEM *item, const char *function, const char *parameter,
+int evaluate_function2(zbx_variant_t *value, DC_ITEM *item, const char *function, const char *parameter,
const zbx_timespec_t *ts, char **error)
{
int ret;
@@ -2258,10 +2253,8 @@ int evaluate_function2(char **value, DC_ITEM *item, const char *function, const
ret = FAIL;
}
- if (SUCCEED == ret)
- del_zeros(*value);
-
- zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s value:'%s'", __func__, zbx_result_string(ret), ZBX_NULL2STR(*value));
+ zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s value:'%s' of type:'%s'", __func__, zbx_result_string(ret),
+ zbx_variant_value_desc(value), zbx_variant_type_desc(value));
return ret;
}
diff --git a/src/libs/zbxserver/expression.c b/src/libs/zbxserver/expression.c
index 378c0e6c0a3..f3c42a64093 100644
--- a/src/libs/zbxserver/expression.c
+++ b/src/libs/zbxserver/expression.c
@@ -5043,6 +5043,7 @@ static void zbx_populate_function_items(const zbx_vector_uint64_t *functionids,
func = (zbx_func_t *)zbx_hashset_insert(funcs, &func_local, sizeof(func_local));
func->function = zbx_strdup(NULL, func_local.function);
func->parameter = zbx_strdup(NULL, func_local.parameter);
+ zbx_variant_set_none(&func->value);
}
ifunc_local.functionid = functions[i].functionid;
@@ -5088,8 +5089,6 @@ static void zbx_evaluate_item_functions(zbx_hashset_t *funcs)
zbx_hashset_iter_reset(funcs, &iter);
while (NULL != (func = (zbx_func_t *)zbx_hashset_iter_next(&iter)))
{
- char *value = NULL;
-
i = zbx_vector_uint64_bsearch(&itemids, func->itemid, ZBX_DEFAULT_UINT64_COMPARE_FUNC);
if (SUCCEED != errcodes[i])
@@ -5114,7 +5113,7 @@ static void zbx_evaluate_item_functions(zbx_hashset_t *funcs)
{
zbx_free(func->error);
func->error = zbx_eval_format_function_error(func->function, items[i].host.host,
- items[i].key_orig, func->parameter, " item belongs to a disabled host.");
+ items[i].key_orig, func->parameter, " item belongs to a disabled host");
continue;
}
@@ -5124,12 +5123,12 @@ static void zbx_evaluate_item_functions(zbx_hashset_t *funcs)
/* set 'unknown' error value */
zbx_variant_set_error(&func->value,
zbx_eval_format_function_error(func->function, items[i].host.host,
- items[i].key_orig, func->parameter, "item is not supported."));
+ items[i].key_orig, func->parameter, "item is not supported"));
continue;
}
- if (SUCCEED != evaluate_function2(&value, &items[i], func->function, func->parameter, &func->timespec,
- &error))
+ if (SUCCEED != evaluate_function2(&func->value, &items[i], func->function, func->parameter,
+ &func->timespec, &error))
{
/* compose and store error message for future use */
zbx_variant_set_error(&func->value,
@@ -5138,8 +5137,6 @@ static void zbx_evaluate_item_functions(zbx_hashset_t *funcs)
zbx_free(error);
continue;
}
-
- zbx_variant_set_str(&func->value, value);
}
DCconfig_clean_items(items, errcodes, itemids.values_num);
diff --git a/tests/libs/zbxhistory/Makefile.am b/tests/libs/zbxhistory/Makefile.am
index 4b47a289c8f..6f8f5eacfee 100644
--- a/tests/libs/zbxhistory/Makefile.am
+++ b/tests/libs/zbxhistory/Makefile.am
@@ -8,7 +8,6 @@ HISTORY_LIBS = \
$(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
$(top_srcdir)/src/libs/zbxcomms/libzbxcomms.a \
$(top_srcdir)/src/libs/zbxcompress/libzbxcompress.a \
- $(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
$(top_srcdir)/src/libs/zbxnix/libzbxnix.a \
$(top_srcdir)/src/libs/zbxcrypto/libzbxcrypto.a \
$(top_srcdir)/src/libs/zbxsys/libzbxsys.a \
@@ -17,6 +16,7 @@ HISTORY_LIBS = \
$(top_srcdir)/src/libs/zbxconf/libzbxconf.a \
$(top_srcdir)/src/libs/zbxmemory/libzbxmemory.a \
$(top_srcdir)/src/libs/zbxhistory/libzbxhistory.a \
+ $(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
$(top_srcdir)/src/libs/zbxjson/libzbxjson.a \
$(top_srcdir)/src/libs/zbxregexp/libzbxregexp.a \
$(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
diff --git a/tests/libs/zbxserver/Makefile.am b/tests/libs/zbxserver/Makefile.am
index 7c93724c262..2f0697d83e2 100755
--- a/tests/libs/zbxserver/Makefile.am
+++ b/tests/libs/zbxserver/Makefile.am
@@ -55,7 +55,6 @@ COMMON_LIB_FILES = \
$(top_srcdir)/src/libs/zbxcrypto/libzbxcrypto.a \
$(top_srcdir)/src/libs/zbxcomms/libzbxcomms.a \
$(top_srcdir)/src/libs/zbxcompress/libzbxcompress.a \
- $(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
$(top_srcdir)/src/libs/zbxsys/libzbxsys.a \
$(top_srcdir)/src/libs/zbxcrypto/libzbxcrypto.a \
$(top_srcdir)/src/libs/zbxcommshigh/libzbxcommshigh.a \
@@ -75,6 +74,7 @@ COMMON_LIB_FILES = \
$(top_srcdir)/src/libs/zbxconf/libzbxconf.a \
$(top_srcdir)/src/libs/zbxhistory/libzbxhistory.a \
$(top_srcdir)/src/zabbix_server/libzbxserver.a \
+ $(top_srcdir)/src/libs/zbxcommon/libzbxcommon.a \
$(top_srcdir)/tests/libzbxmocktest.a \
$(top_srcdir)/tests/libzbxmockdata.a \
$(top_srcdir)/src/libs/zbxalgo/libzbxalgo.a \
diff --git a/tests/libs/zbxserver/evaluate_function.c b/tests/libs/zbxserver/evaluate_function.c
index dc4e30870bf..dfe819809d0 100644
--- a/tests/libs/zbxserver/evaluate_function.c
+++ b/tests/libs/zbxserver/evaluate_function.c
@@ -70,12 +70,13 @@ int __wrap_DCget_data_expected_from(zbx_uint64_t itemid, int *seconds)
void zbx_mock_test_entry(void **state)
{
int err, expected_ret, returned_ret;
- char *error = NULL, *returned_value = NULL;
+ char *error = NULL;
const char *function, *params;
DC_ITEM item;
zbx_vcmock_ds_item_t *ds_item;
zbx_timespec_t ts;
zbx_mock_handle_t handle;
+ zbx_variant_t returned_value;
err = zbx_vc_init(&error);
zbx_mock_assert_result_eq("Value cache initialization failed", SUCCEED, err);
@@ -106,21 +107,38 @@ void zbx_mock_test_entry(void **state)
if (SUCCEED == expected_ret)
{
const char *expected_value;
- char *ptr;
- double expected_dbl;
+ zbx_uint64_t expected_ui64;
handle = zbx_mock_get_parameter_handle("out.value");
if (ZBX_MOCK_SUCCESS != (err = zbx_mock_string_ex(handle, &expected_value)))
fail_msg("Cannot read output value: %s", zbx_mock_error_string(err));
- expected_dbl = strtod(expected_value, &ptr);
-
- if (ptr != expected_value && '\0' == *ptr)
- zbx_mock_assert_double_eq("function result", expected_dbl, atof(returned_value));
- else
- zbx_mock_assert_str_eq("function result", expected_value, returned_value);
+ switch (returned_value.type)
+ {
+ case ZBX_VARIANT_DBL:
+ zbx_mock_assert_double_eq("function result", atof(expected_value),
+ returned_value.data.dbl);
+ break;
+ case ZBX_VARIANT_UI64:
+ if (SUCCEED != is_uint64(expected_value, &expected_ui64))
+ {
+ fail_msg("function result '" ZBX_FS_UI64 "' does not match expected result '%s'",
+ returned_value.data.ui64, expected_value);
+
+ }
+ zbx_mock_assert_uint64_eq("function result", expected_ui64, returned_value.data.ui64);
+ break;
+ case ZBX_VARIANT_STR:
+ zbx_mock_assert_str_eq("function result", expected_value, returned_value.data.str);
+ break;
+ default:
+ fail_msg("function result '%s' has unexpected type '%s'",
+ zbx_variant_value_desc(&returned_value),
+ zbx_variant_type_desc(&returned_value));
+ break;
+ }
}
- zbx_free(returned_value);
+ zbx_variant_clear(&returned_value);
zbx_vcmock_ds_destroy();
diff --git a/tests/libs/zbxserver/evaluate_function.yaml b/tests/libs/zbxserver/evaluate_function.yaml
index d47c458977c..b3d763df904 100644
--- a/tests/libs/zbxserver/evaluate_function.yaml
+++ b/tests/libs/zbxserver/evaluate_function.yaml
@@ -46,7 +46,7 @@ in:
params: ''
out:
return: SUCCEED
- value: '"xyz"'
+ value: 'xyz'
---
test case: Evaluate last() <- '😓...'
in:
@@ -64,10 +64,10 @@ in:
out:
return: SUCCEED
value:
- header: '"'
+ header: ''
page: 😓
pages: 20000
- footer: '"'
+ footer: ''
---
test case: Evaluate last() <- '123'
in:
@@ -82,7 +82,7 @@ in:
params: ''
out:
return: SUCCEED
- value: '"123"'
+ value: '123'
---
test case: Evaluate last() <- ' a b '
in:
@@ -97,7 +97,7 @@ in:
params: ''
out:
return: SUCCEED
- value: '" a b "'
+ value: ' a b '
---
test case: Evaluate last() <- '\"c:\\\"'
in:
@@ -112,7 +112,7 @@ in:
params: ''
out:
return: SUCCEED
- value: '"\"c:\\\""'
+ value: '"c:\"'
---
test case: Evaluate last(:now-10m) <- 0.1, 0.2
in:
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-05 02:39:54 +0300