/******************************************************************************
* *
* Function: proxy_add_history *
* *
* Purpose: add new value to history *
* *
* Parameters: item - item data *
* value - new value of the item *
* now - new value of the item *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void proxy_add_history(DB_ITEM *item, AGENT_RESULT *value, int now)
{
if (value->type & AR_UINT64)
zabbix_log(LOG_LEVEL_DEBUG, "In proxy_add_history(itemid:" ZBX_FS_UI64 ",key:\"%s\",value_type:%d,UINT64:"ZBX_FS_UI64")",
item->itemid,
item->key,
item->value_type,
value->ui64);
if (value->type & AR_STRING)
zabbix_log(LOG_LEVEL_DEBUG, "In proxy_add_history(itemid:" ZBX_FS_UI64 ",key:\"%s\",value_type:%d,STRING:%s)",
item->itemid,
item->key,
item->value_type,
value->str);
if (value->type & AR_DOUBLE)
zabbix_log(LOG_LEVEL_DEBUG, "In proxy_add_history(itemid:" ZBX_FS_UI64 ",key:\"%s\",value_type:%d,DOUBLE:"ZBX_FS_DBL")",
item->itemid,
item->key,
item->value_type,
value->dbl);
if (value->type & AR_TEXT)
zabbix_log(LOG_LEVEL_DEBUG, "In proxy_add_history(itemid: "ZBX_FS_UI64 ",key:\"%s\",value_type:%d,TEXT:[%s])",
item->itemid,
item->key,
item->value_type,
value->text);
switch (item->value_type) {
case ITEM_VALUE_TYPE_FLOAT:
if (GET_DBL_RESULT(value))
DBproxy_add_history(item->itemid, value->dbl, now);
break;
case ITEM_VALUE_TYPE_STR:
if (GET_STR_RESULT(value))
DBproxy_add_history_str(item->itemid, value->str, now);
break;
case ITEM_VALUE_TYPE_LOG:
if (GET_STR_RESULT(value))
DBproxy_add_history_log(item->itemid, value->str, now, item->timestamp, item->eventlog_source,
item->eventlog_severity, item->lastlogsize);
break;
case ITEM_VALUE_TYPE_UINT64:
if (GET_UI64_RESULT(value))
DBproxy_add_history_uint(item->itemid, value->ui64, now);
break;
case ITEM_VALUE_TYPE_TEXT:
if (GET_TEXT_RESULT(value))
DBproxy_add_history_text(item->itemid, value->str, now);
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unknown value type [%d] for itemid [" ZBX_FS_UI64 "]",
item->value_type,
item->itemid);
}
zabbix_log( LOG_LEVEL_DEBUG, "End of proxy_add_history");
}
int EXECUTE_DBL(const char *command, AGENT_RESULT *result)
{
if (SYSINFO_RET_OK != EXECUTE_STR(command, result))
return SYSINFO_RET_FAIL;
if (NULL == GET_DBL_RESULT(result))
{
zabbix_log(LOG_LEVEL_WARNING, "Remote command [%s] result is not double", command);
return SYSINFO_RET_FAIL;
}
UNSET_RESULT_EXCLUDING(result, AR_DOUBLE);
return SYSINFO_RET_OK;
}
int EXECUTE_INT(const char *cmd, const char *command, unsigned flags, AGENT_RESULT *result)
{
int ret = SYSINFO_RET_FAIL;
ret = EXECUTE_STR(cmd,command,flags,result);
if(SYSINFO_RET_OK == ret)
{
if( NULL == GET_DBL_RESULT(result) )
{
zabbix_log(LOG_LEVEL_WARNING, "Remote command [%s] result is not double", command);
ret = SYSINFO_RET_FAIL;
}
UNSET_RESULT_EXCLUDING(result, AR_DOUBLE);
}
return ret;
}
int NET_TCP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
char command[MAX_STRING_LEN];
int res;
assert(result);
init_result(result);
zbx_snprintf(command, sizeof(command), "netstat -an | grep '*.%s\\>' | wc -l", param);
if (SYSINFO_RET_FAIL == (res = EXECUTE_INT(NULL, command, flags, result)))
return res;
if (NULL != GET_DBL_RESULT(result))
if (result->dbl > 1)
result->dbl = 1;
return res;
}
/******************************************************************************
* *
* Function: update_item *
* *
* Purpose: update item info after new value is received *
* *
* Parameters: item - item data *
* value - new value of the item *
* now - current timestamp *
* *
* Author: Alexei Vladishev, Eugene Grigorjev *
* *
* Comments: *
* *
******************************************************************************/
static void update_item(DB_ITEM *item, AGENT_RESULT *value, time_t now)
{
char *value_esc;
zbx_uint64_t value_uint64;
double value_double;
zabbix_log(LOG_LEVEL_DEBUG, "In update_item()");
item->nextcheck = calculate_item_nextcheck(item->itemid, item->type, item->delay, item->delay_flex, now);
switch (item->value_type) {
case ITEM_VALUE_TYPE_FLOAT:
if (NULL == GET_DBL_RESULT(value))
break;
switch (item->delta) { /* Should we store delta or original value? */
case ITEM_STORE_AS_IS:
value_double = DBmultiply_value_float(item, value->dbl);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue=NULL,"
"lastvalue='" ZBX_FS_DBL "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value_double,
(int)now,
item->itemid);
SET_DBL_RESULT(value, value_double);
break;
case ITEM_STORE_SPEED_PER_SECOND: /* Delta as speed of change */
if (0 == item->prevorgvalue_null && item->prevorgvalue_dbl <= value->dbl)
{
/* In order to continue normal processing, we assume difference 1 second
Otherwise function update_functions and update_triggers won't work correctly*/
if (now != item->lastclock)
value_double = (value->dbl - item->prevorgvalue_dbl) / (now - item->lastclock);
else
value_double = value->dbl - item->prevorgvalue_dbl;
value_double = DBmultiply_value_float(item, value_double);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue='" ZBX_FS_DBL "',"
"lastvalue='" ZBX_FS_DBL "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->dbl,
value_double,
(int)now,
item->itemid);
SET_DBL_RESULT(value, value_double);
}
else
{
DBexecute("update items set nextcheck=%d,prevorgvalue='" ZBX_FS_DBL "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->dbl,
(int)now,
item->itemid);
}
break;
case ITEM_STORE_SIMPLE_CHANGE: /* Real delta: simple difference between values */
if (0 == item->prevorgvalue_null && item->prevorgvalue_dbl <= value->dbl)
{
value_double = DBmultiply_value_float(item, value->dbl - item->prevorgvalue_dbl);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue='" ZBX_FS_DBL "',"
"lastvalue='" ZBX_FS_DBL "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->dbl,
value_double,
(int)now,
item->itemid);
SET_DBL_RESULT(value, value_double);
}
else
{
DBexecute("update items set nextcheck=%d,prevorgvalue='" ZBX_FS_DBL "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->dbl,
(int)now,
item->itemid);
}
break;
}
break;
case ITEM_VALUE_TYPE_UINT64:
if (NULL == GET_UI64_RESULT(value))
break;
switch (item->delta) { /* Should we store delta or original value? */
case ITEM_STORE_AS_IS:
value_uint64 = DBmultiply_value_uint64(item, value->ui64);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue=NULL,"
"lastvalue='" ZBX_FS_UI64 "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value_uint64,
(int)now,
item->itemid);
SET_UI64_RESULT(value, value_uint64);
break;
case ITEM_STORE_SPEED_PER_SECOND: /* Delta as speed of change */
if (0 == item->prevorgvalue_null && item->prevorgvalue_uint64 <= value->ui64)
{
if (now != item->lastclock)
value_uint64 = (zbx_uint64_t)(value->ui64 - item->prevorgvalue_uint64) / (now - item->lastclock);
else
value_uint64 = value->ui64 - item->prevorgvalue_uint64;
value_uint64 = DBmultiply_value_uint64(item, value_uint64);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue='" ZBX_FS_UI64 "',"
"lastvalue='" ZBX_FS_UI64 "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->ui64,
value_uint64,
(int)now,
item->itemid);
SET_UI64_RESULT(value, value_uint64);
}
else
{
DBexecute("update items set nextcheck=%d,prevorgvalue='" ZBX_FS_UI64 "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->ui64,
(int)now,
item->itemid);
}
break;
case ITEM_STORE_SIMPLE_CHANGE: /* Real delta: simple difference between values */
if (0 == item->prevorgvalue_null && item->prevorgvalue_uint64 <= value->ui64)
{
value_uint64 = DBmultiply_value_uint64(item, value->ui64 - item->prevorgvalue_uint64);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,prevorgvalue='" ZBX_FS_UI64 "',"
"lastvalue='" ZBX_FS_UI64 "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->ui64,
value_uint64,
(int)now,
item->itemid);
SET_UI64_RESULT(value, value_uint64);
}
else
{
DBexecute("update items set nextcheck=%d,prevorgvalue='" ZBX_FS_UI64 "',lastclock=%d where itemid=" ZBX_FS_UI64,
item->nextcheck,
value->ui64,
(int)now,
item->itemid);
}
break;
}
break;
case ITEM_VALUE_TYPE_STR:
case ITEM_VALUE_TYPE_TEXT:
if (NULL == GET_STR_RESULT(value))
break;
value_esc = DBdyn_escape_string_len(value->str, ITEM_LASTVALUE_LEN);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,lastvalue='%s',lastclock=%d"
" where itemid=" ZBX_FS_UI64,
item->nextcheck,
value_esc,
(int)now,
item->itemid);
zbx_free(value_esc);
break;
case ITEM_VALUE_TYPE_LOG:
if (NULL == GET_STR_RESULT(value))
break;
value_esc = DBdyn_escape_string_len(value->str, ITEM_LASTVALUE_LEN);
DBexecute("update items set nextcheck=%d,prevvalue=lastvalue,lastvalue='%s',lastclock=%d,lastlogsize=%d"
" where itemid=" ZBX_FS_UI64,
item->nextcheck,
value_esc,
(int)now,
item->lastlogsize,
item->itemid);
zbx_free(value_esc);
break;
}
item->prevvalue_str = item->lastvalue_str;
item->prevvalue_dbl = item->lastvalue_dbl;
item->prevvalue_uint64 = item->lastvalue_uint64;
item->prevvalue_null = item->lastvalue_null;
item->lastvalue_uint64 = value->ui64;
item->lastvalue_dbl = value->dbl;
item->lastvalue_str = value->str;
item->lastvalue_null = 0;
/* Required for nodata() */
item->lastclock = now;
/* Update item status if required */
if (item->status == ITEM_STATUS_NOTSUPPORTED)
{
zabbix_log( LOG_LEVEL_WARNING, "Parameter [%s] became supported by agent on host [%s]",
item->key,
item->host_name);
zabbix_syslog("Parameter [%s] became supported by agent on host [%s]",
item->key,
item->host_name);
item->status = ITEM_STATUS_ACTIVE;
DBexecute("update items set status=%d,error='' where itemid=" ZBX_FS_UI64,
item->status,
item->itemid);
}
zabbix_log(LOG_LEVEL_DEBUG, "End of update_item()");
}
/******************************************************************************
* *
* Function: add_history *
* *
* Purpose: add new value to history *
* *
* Parameters: item - item data *
* value - new value of the item *
* now - new value of the item *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int add_history(DB_ITEM *item, AGENT_RESULT *value, int now)
{
int ret = FAIL;
zbx_uint64_t value_uint64;
double value_double;
zabbix_log(LOG_LEVEL_DEBUG, "In add_history(key:%s,value_type:%X,type:%X)",
item->key,
item->value_type,
value->type);
if (value->type & AR_UINT64)
zabbix_log(LOG_LEVEL_DEBUG, "In add_history(itemid:"ZBX_FS_UI64",UINT64:"ZBX_FS_UI64")",
item->itemid,
value->ui64);
if (value->type & AR_STRING)
zabbix_log(LOG_LEVEL_DEBUG, "In add_history(itemid:"ZBX_FS_UI64",STRING:%s)",
item->itemid,
value->str);
if (value->type & AR_DOUBLE)
zabbix_log(LOG_LEVEL_DEBUG, "In add_history(itemid:"ZBX_FS_UI64",DOUBLE:"ZBX_FS_DBL")",
item->itemid,
value->dbl);
if (value->type & AR_TEXT)
zabbix_log(LOG_LEVEL_DEBUG, "In add_history(itemid:"ZBX_FS_UI64",TEXT:[%s])",
item->itemid,
value->text);
switch (item->value_type) {
case ITEM_VALUE_TYPE_FLOAT:
if (NULL == GET_DBL_RESULT(value))
break;
switch (item->delta) { /* Should we store delta or original value? */
case ITEM_STORE_AS_IS:
if (item->history > 0)
DBadd_history(item->itemid, DBmultiply_value_float(item, value->dbl), now);
ret = SUCCEED;
break;
case ITEM_STORE_SPEED_PER_SECOND: /* Delta as speed of change */
if (0 == item->prevorgvalue_null && item->prevorgvalue_dbl <= value->dbl && item->lastclock < now)
{
if (item->history > 0)
{
value_double = (value->dbl - item->prevorgvalue_dbl) / (now - item->lastclock);
DBadd_history(item->itemid, DBmultiply_value_float(item, value_double), now);
}
ret = SUCCEED;
}
break;
case ITEM_STORE_SIMPLE_CHANGE: /* Real delta: simple difference between values */
if (0 == item->prevorgvalue_null && item->prevorgvalue_dbl <= value->dbl)
{
if (item->history > 0)
DBadd_history(item->itemid, DBmultiply_value_float(item, value->dbl - item->prevorgvalue_dbl), now);
ret = SUCCEED;
}
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Value not stored for itemid [" ZBX_FS_UI64 "]. Unknown delta [%d]",
item->itemid,
item->delta);
zabbix_syslog("Value not stored for itemid [" ZBX_FS_UI64 "]. Unknown delta [%d]",
item->itemid,
item->delta);
}
break;
case ITEM_VALUE_TYPE_UINT64:
if (NULL == GET_UI64_RESULT(value))
break;
switch (item->delta) { /* Should we store delta or original value? */
case ITEM_STORE_AS_IS:
if (item->history > 0)
DBadd_history_uint(item->itemid, DBmultiply_value_uint64(item, value->ui64), now);
ret = SUCCEED;
break;
case ITEM_STORE_SPEED_PER_SECOND: /* Delta as speed of change */
if (0 == item->prevorgvalue_null && item->prevorgvalue_uint64 <= value->ui64 && item->lastclock < now)
{
if (item->history > 0)
{
value_uint64 = (zbx_uint64_t)(value->ui64 - item->prevorgvalue_uint64) / (now - item->lastclock);
DBadd_history_uint(item->itemid, DBmultiply_value_uint64(item, value_uint64), now);
}
ret = SUCCEED;
}
break;
case ITEM_STORE_SIMPLE_CHANGE: /* Real delta: simple difference between values */
if (0 == item->prevorgvalue_null && item->prevorgvalue_uint64 <= value->ui64)
{
if (item->history > 0)
DBadd_history_uint(item->itemid, DBmultiply_value_uint64(item, value->ui64 - item->prevorgvalue_uint64), now);
ret = SUCCEED;
}
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Value not stored for itemid [" ZBX_FS_UI64 "]. Unknown delta [%d]",
item->itemid,
item->delta);
zabbix_syslog("Value not stored for itemid [" ZBX_FS_UI64 "]. Unknown delta [%d]",
item->itemid,
item->delta);
}
break;
case ITEM_VALUE_TYPE_STR:
if (NULL == GET_STR_RESULT(value))
break;
if (item->history > 0)
DBadd_history_str(item->itemid, value->str, now);
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_LOG:
if (NULL == GET_STR_RESULT(value))
break;
if (item->history > 0)
DBadd_history_log(item->itemid, value->str, now, item->timestamp, item->eventlog_source,
item->eventlog_severity, item->lastlogsize);
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_TEXT:
if (NULL == GET_TEXT_RESULT(value))
break;
if (item->history > 0)
DBadd_history_text(item->itemid,value->text,now);
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unknown value type [%d] for itemid [" ZBX_FS_UI64 "]",
item->value_type,
item->itemid);
zabbix_syslog("Unknown value type [%d] for itemid [" ZBX_FS_UI64 "]",
item->value_type,
item->itemid);
}
zabbix_log(LOG_LEVEL_DEBUG, "End of add_history():%s",
zbx_result_string(ret));
return ret;
}
