/* This is separate due to it being required from inside the tests. */
void setup_objects (void) {
init_objects_command(1);
cmd = create_command("my_command", "/bin/true");
ck_assert(cmd != NULL);
register_command(cmd);
init_objects_host(1);
hst = create_host(TARGET_HOST_NAME);
ck_assert(hst != NULL);
hst->check_command_ptr = cmd;
hst->retain_status_information = TRUE;
register_host(hst);
init_objects_service(1);
svc = create_service(hst, TARGET_SERVICE_NAME);
ck_assert(svc != NULL);
svc->check_command_ptr = cmd;
svc->retain_status_information = TRUE;
register_service(svc);
}
void load_state(void)
{
char *tmpdir;
char *fn;
FILE *fd;
char buf[4096];
char *tname, *sname, *sconfweight, *sactweight, *ssticky, *sextra, *hname;
enum locator_servicetype_t stype;
tmpdir = xgetenv("XYMONTMP"); if (!tmpdir) tmpdir = "/tmp";
fn = (char *)malloc(strlen(tmpdir) + 100);
sprintf(fn, "%s/locator.servers.chk", tmpdir);
fd = fopen(fn, "r");
if (fd) {
while (fgets(buf, sizeof(buf), fd)) {
serverinfo_t *srv;
tname = sname = sconfweight = sactweight = ssticky = sextra = NULL;
tname = strtok(buf, "|\n");
if (tname) sname = strtok(NULL, "|\n");
if (sname) sconfweight = strtok(NULL, "|\n");
if (sconfweight) sactweight = strtok(NULL, "|\n");
if (sactweight) ssticky = strtok(NULL, "|\n");
if (ssticky) sextra = strtok(NULL, "\n");
if (tname && sname && sconfweight && sactweight && ssticky) {
enum locator_sticky_t sticky = (atoi(ssticky) == 1) ? LOC_STICKY : LOC_ROAMING;
stype = get_servicetype(tname);
srv = register_server(sname, stype, atoi(sconfweight), sticky, sextra);
srv->serveractualweight = atoi(sactweight);
dbgprintf("Loaded server %s/%s (cweight %d, aweight %d, %s)\n",
srv->servername, tname, srv->serverconfweight, srv->serveractualweight,
(srv->sticky ? "sticky" : "not sticky"));
}
}
fclose(fd);
}
for (stype = 0; (stype < ST_MAX); stype++) recalc_current(stype);
sprintf(fn, "%s/locator.hosts.chk", tmpdir);
fd = fopen(fn, "r");
if (fd) {
while (fgets(buf, sizeof(buf), fd)) {
tname = hname = sname = NULL;
tname = strtok(buf, "|\n");
if (tname) hname = strtok(NULL, "|\n");
if (hname) sname = strtok(NULL, "|\n");
if (tname && hname && sname) {
enum locator_servicetype_t stype = get_servicetype(tname);
register_host(hname, stype, sname);
dbgprintf("Loaded host %s/%s for server %s\n", hname, tname, sname);
}
}
fclose(fd);
}
}
void handle_request(char *buf)
{
const char *delims = "|\r\n\t ";
switch (buf[0]) {
case 'S':
/* Register server|type|weight|sticky|extras */
{
char *tok, *servername = NULL;
enum locator_servicetype_t servicetype = ST_MAX;
int serverweight = 0;
enum locator_sticky_t sticky = LOC_ROAMING;
char *serverextras = NULL;
tok = strtok(buf, delims); if (tok) { tok = strtok(NULL, delims); }
if (tok) { servername = tok; tok = strtok(NULL, delims); }
if (tok) { servicetype = get_servicetype(tok); tok = strtok(NULL, delims); }
if (tok) { serverweight = atoi(tok); tok = strtok(NULL, delims); }
if (tok) { sticky = ((atoi(tok) == 1) ? LOC_STICKY : LOC_ROAMING); tok = strtok(NULL, delims); }
if (tok) { serverextras = tok; tok = strtok(NULL, delims); }
if (servername && (servicetype != ST_MAX)) {
dbgprintf("Registering server '%s' handling %s (weight %d, %s)\n",
servername, servicetype_names[servicetype], serverweight,
(sticky == LOC_STICKY ? "sticky" : "not sticky"));
register_server(servername, servicetype, serverweight, sticky, serverextras);
strcpy(buf, "OK");
}
else strcpy(buf, "BADSYNTAX");
}
break;
case 'D': case 'U': case 'F':
/* Down/Up/Forget server|type */
{
char *tok, *servername = NULL;
enum locator_servicetype_t servicetype = ST_MAX;
tok = strtok(buf, delims); if (tok) { tok = strtok(NULL, delims); }
if (tok) { servername = tok; tok = strtok(NULL, delims); }
if (tok) { servicetype = get_servicetype(tok); tok = strtok(NULL, delims); }
if (servername && (servicetype != ST_MAX)) {
downup_server(servername, servicetype, buf[0]);
strcpy(buf, "OK");
}
else strcpy(buf, "BADSYNTAX");
}
break;
case 'H':
/* Register host|type|server */
{
char *tok, *hostname = NULL, *servername = NULL;
enum locator_servicetype_t servicetype = ST_MAX;
tok = strtok(buf, delims); if (tok) { tok = strtok(NULL, delims); }
if (tok) { hostname = tok; tok = strtok(NULL, delims); }
if (tok) { servicetype = get_servicetype(tok); tok = strtok(NULL, delims); }
if (tok) { servername = tok; tok = strtok(NULL, delims); }
if (hostname && (servicetype != ST_MAX) && servername) {
dbgprintf("Registering type/host %s/%s handled by server %s\n",
servicetype_names[servicetype], hostname, servername);
register_host(hostname, servicetype, servername);
strcpy(buf, "OK");
}
else strcpy(buf, "BADSYNTAX");
}
break;
case 'M':
/* Rename host|type|newhostname */
{
char *tok, *oldhostname = NULL, *newhostname = NULL;
enum locator_servicetype_t servicetype = ST_MAX;
tok = strtok(buf, delims); if (tok) { tok = strtok(NULL, delims); }
if (tok) { oldhostname = tok; tok = strtok(NULL, delims); }
if (tok) { servicetype = get_servicetype(tok); tok = strtok(NULL, delims); }
if (tok) { newhostname = tok; tok = strtok(NULL, delims); }
if (oldhostname && (servicetype != ST_MAX) && newhostname) {
dbgprintf("Renaming type/host %s/%s to %s\n",
servicetype_names[servicetype], oldhostname, newhostname);
if (rename_host(oldhostname, servicetype, newhostname)) {
strcpy(buf, "OK");
}
else {
strcpy(buf, "FAILED");
}
}
else strcpy(buf, "BADSYNTAX");
}
break;
case 'X':
case 'Q':
/* Query type|host */
{
char *tok, *hostname = NULL;
enum locator_servicetype_t servicetype = ST_MAX;
int extquery = (buf[0] == 'X');
serverinfo_t *res = NULL;
tok = strtok(buf, delims); if (tok) { tok = strtok(NULL, delims); }
if (tok) { servicetype = get_servicetype(tok); tok = strtok(NULL, delims); }
if (tok) { hostname = tok; tok = strtok(NULL, delims); }
if ((servicetype != ST_MAX) && hostname) {
res = find_server_by_host(servicetype, hostname);
if (res) {
/* This host is fixed on a specific server ... */
if (res->serveractualweight > 0) {
/* ... and that server is UP */
sprintf(buf, "!|%s", res->servername);
}
else {
/* ... and the server is DOWN, so we cannot service the request */
strcpy(buf, "?");
}
}
else {
/* Roaming or un-registered host */
res = find_server_by_type(servicetype);
if (res) {
if (res->sticky == LOC_STICKY) {
dbgprintf("Host %s/%s now fixed on server %s\n",
hostname, servicetype_names[servicetype], res->servername);
register_host(hostname, servicetype, res->servername);
}
sprintf(buf, "*|%s", res->servername);
}
else {
strcpy(buf, "?");
}
}
if (res && extquery) {
int blen = strlen(buf);
snprintf(buf+blen, sizeof(buf)-blen-1, "|%s", res->serverextras);
}
}
else strcpy(buf, "BADSYNTAX");
}
break;
case 'p':
/* Locator ping */
sprintf(buf, "PONG|%s", VERSION);
break;
case '@':
/* Save state */
save_state();
strcpy(buf, "OK");
break;
default:
strcpy(buf, "BADREQUEST");
break;
}
}
/******************************************************************************
* *
* Function: update_service *
* *
* Purpose: process new service status *
* *
* Parameters: service - service info *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void update_service(DB_DRULE *rule, DB_DCHECK *check, char *ip, int port)
{
int now;
DB_DHOST host;
DB_DSERVICE service;
assert(rule);
assert(check);
assert(ip);
zabbix_log(LOG_LEVEL_DEBUG, "In update_service(ip:%s, port:%d, status:%s)",
ip,
port,
(check->status==DOBJECT_STATUS_UP?"up":"down"));
service.dserviceid=0;
/* Register host if is not registered yet */
register_host(&host,check,rule->druleid,ip);
if(host.dhostid>0)
{
/* Register service if is not registered yet */
/* dserviceid = register_service(rule,check,host.dhostid,ip,port);*/
register_service(&service,rule,check,host.dhostid,ip,port);
}
if(service.dserviceid == 0)
{
/* Service wasn't registered because we do not add down service */
return;
}
now = time(NULL);
if(check->status == DOBJECT_STATUS_UP)
{
/* Update host status */
if(host.status == DOBJECT_STATUS_DOWN || host.lastup==0)
{
host.status=DOBJECT_STATUS_UP;
host.lastdown=0;
host.lastup=now;
update_dhost(&host);
}
/* Update service status */
if(service.status == DOBJECT_STATUS_DOWN || service.lastup==0)
{
service.status=DOBJECT_STATUS_UP;
service.lastdown=0;
service.lastup=now;
update_dservice(&service);
}
}
/* DOBJECT_STATUS_DOWN */
else
{
if(host.status == DOBJECT_STATUS_UP || host.lastdown==0)
{
host.status=DOBJECT_STATUS_DOWN;
host.lastdown=now;
host.lastup=0;
update_dhost(&host);
}
/* Update service status */
if(service.status == DOBJECT_STATUS_UP || service.lastdown==0)
{
service.status=DOBJECT_STATUS_DOWN;
service.lastdown=now;
service.lastup=0;
update_dservice(&service);
}
}
add_service_event(&service);
}
