410 lines
9.9 KiB
C
410 lines
9.9 KiB
C
/*
|
|
* This file is distributed as part of the MariaDB Corporation MaxScale. It 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,
|
|
* version 2.
|
|
*
|
|
* 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.
|
|
*
|
|
* Copyright MariaDB Corporation Ab 2013-2015
|
|
*/
|
|
|
|
#include <monitor_common.h>
|
|
|
|
monitor_event_t mon_name_to_event(char* tok);
|
|
|
|
/**
|
|
* Set a pending status bit in the monitor server
|
|
*
|
|
* @param server The server to update
|
|
* @param bit The bit to clear for the server
|
|
*/
|
|
void monitor_set_pending_status(MONITOR_SERVERS *ptr, int bit)
|
|
{
|
|
ptr->pending_status |= bit;
|
|
}
|
|
|
|
/**
|
|
* Clear a pending status bit in the monitor server
|
|
*
|
|
* @param server The server to update
|
|
* @param bit The bit to clear for the server
|
|
*/
|
|
void monitor_clear_pending_status(MONITOR_SERVERS *ptr, int bit)
|
|
{
|
|
ptr->pending_status &= ~bit;
|
|
}
|
|
|
|
|
|
monitor_event_t mon_get_event_type(MONITOR_SERVERS* node)
|
|
{
|
|
unsigned int prev = node->mon_prev_status;
|
|
|
|
if((prev & (SERVER_MASTER|SERVER_RUNNING)) == (SERVER_MASTER|SERVER_RUNNING) &&
|
|
SERVER_IS_DOWN(node->server))
|
|
{
|
|
return MASTER_DOWN_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING)) == 0 &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_MASTER(node->server))
|
|
{
|
|
return MASTER_UP_EVENT;
|
|
}
|
|
if((prev & (SERVER_SLAVE|SERVER_RUNNING)) == (SERVER_SLAVE|SERVER_RUNNING) &&
|
|
SERVER_IS_DOWN(node->server))
|
|
{
|
|
return SLAVE_DOWN_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING)) == 0 &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_SLAVE(node->server))
|
|
{
|
|
return SLAVE_UP_EVENT;
|
|
}
|
|
|
|
/** Galera specific events */
|
|
if((prev & (SERVER_JOINED|SERVER_RUNNING)) == (SERVER_JOINED|SERVER_RUNNING) &&
|
|
SERVER_IS_DOWN(node->server))
|
|
{
|
|
return SYNCED_DOWN_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING)) == 0 &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_JOINED(node->server))
|
|
{
|
|
return SYNCED_UP_EVENT;
|
|
}
|
|
|
|
/** NDB events*/
|
|
if((prev & (SERVER_NDB|SERVER_RUNNING)) == (SERVER_NDB|SERVER_RUNNING) &&
|
|
SERVER_IS_DOWN(node->server))
|
|
{
|
|
return NDB_DOWN_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING)) == 0 &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_NDB(node->server))
|
|
{
|
|
return NDB_UP_EVENT;
|
|
}
|
|
|
|
if((prev & (SERVER_RUNNING)) == SERVER_RUNNING &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_MASTER(node->server))
|
|
{
|
|
return NEW_MASTER_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING)) == SERVER_RUNNING &&
|
|
SERVER_IS_RUNNING(node->server) && SERVER_IS_SLAVE(node->server))
|
|
{
|
|
return NEW_SLAVE_EVENT;
|
|
}
|
|
|
|
/** Status loss events */
|
|
if((prev & (SERVER_RUNNING|SERVER_MASTER)) == (SERVER_RUNNING|SERVER_MASTER) &&
|
|
SERVER_IS_RUNNING(node->server) && !SERVER_IS_MASTER(node->server))
|
|
{
|
|
return LOST_MASTER_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING|SERVER_SLAVE)) == (SERVER_RUNNING|SERVER_SLAVE) &&
|
|
SERVER_IS_RUNNING(node->server) && !SERVER_IS_SLAVE(node->server))
|
|
{
|
|
return LOST_SLAVE_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING|SERVER_JOINED)) == (SERVER_RUNNING|SERVER_JOINED) &&
|
|
SERVER_IS_RUNNING(node->server) && !SERVER_IS_JOINED(node->server))
|
|
{
|
|
return LOST_SYNCED_EVENT;
|
|
}
|
|
if((prev & (SERVER_RUNNING|SERVER_NDB)) == (SERVER_RUNNING|SERVER_NDB) &&
|
|
SERVER_IS_RUNNING(node->server) && !SERVER_IS_NDB(node->server))
|
|
{
|
|
return LOST_NDB_EVENT;
|
|
}
|
|
|
|
|
|
/** Generic server failure */
|
|
if((prev & SERVER_RUNNING) == 0 &&
|
|
SERVER_IS_RUNNING(node->server))
|
|
{
|
|
return SERVER_UP_EVENT;
|
|
}
|
|
if((prev & SERVER_RUNNING) == SERVER_RUNNING &&
|
|
SERVER_IS_DOWN(node->server))
|
|
{
|
|
return SERVER_DOWN_EVENT;
|
|
}
|
|
|
|
/** Something else, most likely a state that does not matter.
|
|
* For example SERVER_DOWN -> SERVER_MASTER|SERVER_DOWN still results in a
|
|
* server state equal to not running.*/
|
|
return UNDEFINED_MONITOR_EVENT;
|
|
}
|
|
|
|
char* mon_get_event_name(MONITOR_SERVERS* node)
|
|
{
|
|
switch(mon_get_event_type(node))
|
|
{
|
|
case UNDEFINED_MONITOR_EVENT:
|
|
return "undefined";
|
|
|
|
case MASTER_DOWN_EVENT:
|
|
return "master_down";
|
|
|
|
case MASTER_UP_EVENT:
|
|
return "master_up";
|
|
|
|
case SLAVE_DOWN_EVENT:
|
|
return "slave_down";
|
|
|
|
case SLAVE_UP_EVENT:
|
|
return "slave_up";
|
|
|
|
case SERVER_DOWN_EVENT:
|
|
return "server_down";
|
|
|
|
case SERVER_UP_EVENT:
|
|
return "server_up";
|
|
|
|
case SYNCED_DOWN_EVENT:
|
|
return "synced_down";
|
|
|
|
case SYNCED_UP_EVENT:
|
|
return "synced_up";
|
|
|
|
case DONOR_DOWN_EVENT:
|
|
return "donor_down";
|
|
|
|
case DONOR_UP_EVENT:
|
|
return "donor_up";
|
|
|
|
case NDB_DOWN_EVENT:
|
|
return "ndb_down";
|
|
|
|
case NDB_UP_EVENT:
|
|
return "ndb_up";
|
|
|
|
case LOST_MASTER_EVENT:
|
|
return "lost_master";
|
|
|
|
case LOST_SLAVE_EVENT:
|
|
return "lost_slave";
|
|
|
|
case LOST_SYNCED_EVENT:
|
|
return "lost_synced";
|
|
|
|
case LOST_DONOR_EVENT:
|
|
return "lost_donor";
|
|
|
|
case LOST_NDB_EVENT:
|
|
return "lost_ndb";
|
|
|
|
case NEW_MASTER_EVENT:
|
|
return "new_master";
|
|
|
|
case NEW_SLAVE_EVENT:
|
|
return "new_slave";
|
|
|
|
case NEW_SYNCED_EVENT:
|
|
return "new_synced";
|
|
|
|
case NEW_DONOR_EVENT:
|
|
return "new_donor";
|
|
|
|
case NEW_NDB_EVENT:
|
|
return "new_ndb";
|
|
|
|
default:
|
|
return "MONITOR_EVENT_FAILURE";
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void mon_append_node_names(MONITOR_SERVERS* start,char* str, int len)
|
|
{
|
|
MONITOR_SERVERS* ptr = start;
|
|
bool first = true;
|
|
int slen = strlen(str);
|
|
char arr[256];
|
|
while(ptr && slen < len)
|
|
{
|
|
if(!first)
|
|
{
|
|
strncat(str,",",len);
|
|
}
|
|
first = false;
|
|
sprintf(arr,"%s:%d",ptr->server->name,ptr->server->port);
|
|
strcat(str,arr);
|
|
ptr = ptr->next;
|
|
slen = strlen(str);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check if current monitored server status has changed
|
|
*
|
|
* @param mon_srv The monitored server
|
|
* @return true if status has changed or false
|
|
*/
|
|
bool mon_status_changed(
|
|
MONITOR_SERVERS* mon_srv)
|
|
{
|
|
bool succp;
|
|
|
|
/** This is the first time the server was set with a status*/
|
|
if (mon_srv->mon_prev_status == -1)
|
|
return false;
|
|
|
|
if (mon_srv->mon_prev_status != mon_srv->server->status)
|
|
{
|
|
succp = true;
|
|
}
|
|
else
|
|
{
|
|
succp = false;
|
|
}
|
|
return succp;
|
|
}
|
|
|
|
/**
|
|
* Check if current monitored server has a loggable failure status
|
|
*
|
|
* @param mon_srv The monitored server
|
|
* @return true if failed status can be logged or false
|
|
*/
|
|
bool mon_print_fail_status(
|
|
MONITOR_SERVERS* mon_srv)
|
|
{
|
|
bool succp;
|
|
int errcount = mon_srv->mon_err_count;
|
|
|
|
if (SERVER_IS_DOWN(mon_srv->server) && errcount == 0)
|
|
{
|
|
succp = true;
|
|
}
|
|
else
|
|
{
|
|
succp = false;
|
|
}
|
|
return succp;
|
|
}
|
|
|
|
void monitor_launch_script(MONITOR* mon,MONITOR_SERVERS* ptr, char* script)
|
|
{
|
|
char argstr[PATH_MAX + MON_ARG_MAX + 1];
|
|
EXTERNCMD* cmd;
|
|
|
|
snprintf(argstr,PATH_MAX + MON_ARG_MAX,
|
|
"%s --event=%s --initiator=%s:%d --nodelist=",
|
|
script,
|
|
mon_get_event_name(ptr),
|
|
ptr->server->name,
|
|
ptr->server->port);
|
|
|
|
mon_append_node_names(mon->databases,argstr,PATH_MAX + MON_ARG_MAX + 1);
|
|
if((cmd = externcmd_allocate(argstr)) == NULL)
|
|
{
|
|
skygw_log_write(LE,"Failed to execute script: %s",script);
|
|
return;
|
|
}
|
|
|
|
if(externcmd_execute(cmd))
|
|
{
|
|
skygw_log_write(LOGFILE_ERROR,
|
|
"Error: Failed to execute script "
|
|
"'%s' on server state change event %s.",
|
|
script,mon_get_event_type(ptr));
|
|
}
|
|
externcmd_free(cmd);
|
|
}
|
|
|
|
/**
|
|
* Parse a string of event names to an array with enabled events.
|
|
* @param events Pointer to an array of boolean values
|
|
* @param count Size of the array
|
|
* @param string String to parse
|
|
* @return 0 on success. 1 when an error has occurred or an unexpected event was
|
|
* found.
|
|
*/
|
|
int mon_parse_event_string(bool* events, size_t count,char* string)
|
|
{
|
|
char *tok,*saved;
|
|
monitor_event_t event;
|
|
|
|
tok = strtok_r(string,",| ",&saved);
|
|
|
|
if(tok == NULL)
|
|
return -1;
|
|
|
|
while(tok)
|
|
{
|
|
event = mon_name_to_event(tok);
|
|
if(event == UNDEFINED_MONITOR_EVENT)
|
|
{
|
|
skygw_log_write(LE,"Error: Invalid event name %s",tok);
|
|
return -1;
|
|
}
|
|
events[event] = true;
|
|
tok = strtok_r(NULL,",| ",&saved);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
monitor_event_t mon_name_to_event(char* tok)
|
|
{
|
|
if(!strcasecmp("master_down",tok))
|
|
return MASTER_DOWN_EVENT;
|
|
else if(!strcasecmp("master_up",tok))
|
|
return MASTER_UP_EVENT;
|
|
else if(!strcasecmp("slave_down",tok))
|
|
return SLAVE_DOWN_EVENT;
|
|
else if(!strcasecmp("slave_up",tok))
|
|
return SLAVE_UP_EVENT;
|
|
else if(!strcasecmp("server_down",tok))
|
|
return SERVER_DOWN_EVENT;
|
|
else if(!strcasecmp("server_up",tok))
|
|
return SERVER_UP_EVENT;
|
|
else if(!strcasecmp("synced_down",tok))
|
|
return SYNCED_DOWN_EVENT;
|
|
else if(!strcasecmp("synced_up",tok))
|
|
return SYNCED_UP_EVENT;
|
|
else if(!strcasecmp("donor_down",tok))
|
|
return DONOR_DOWN_EVENT;
|
|
else if(!strcasecmp("donor_up",tok))
|
|
return DONOR_UP_EVENT;
|
|
else if(!strcasecmp("ndb_down",tok))
|
|
return NDB_DOWN_EVENT;
|
|
else if(!strcasecmp("ndb_up",tok))
|
|
return NDB_UP_EVENT;
|
|
else if(!strcasecmp("lost_master",tok))
|
|
return LOST_MASTER_EVENT;
|
|
else if(!strcasecmp("lost_slave",tok))
|
|
return LOST_SLAVE_EVENT;
|
|
else if(!strcasecmp("lost_synced",tok))
|
|
return LOST_SYNCED_EVENT;
|
|
else if(!strcasecmp("lost_donor",tok))
|
|
return LOST_DONOR_EVENT;
|
|
else if(!strcasecmp("lost_ndb",tok))
|
|
return LOST_NDB_EVENT;
|
|
else if(!strcasecmp("new_master",tok))
|
|
return NEW_MASTER_EVENT;
|
|
else if(!strcasecmp("new_slave",tok))
|
|
return NEW_SLAVE_EVENT;
|
|
else if(!strcasecmp("new_synced",tok))
|
|
return NEW_SYNCED_EVENT;
|
|
else if(!strcasecmp("new_donor",tok))
|
|
return NEW_DONOR_EVENT;
|
|
else if(!strcasecmp("new_ndb",tok))
|
|
return NEW_NDB_EVENT;
|
|
else
|
|
return UNDEFINED_MONITOR_EVENT;
|
|
|
|
}
|
|
|