diff --git a/server/core/monitor.c b/server/core/monitor.c index afad7d7da..97632ce9d 100644 --- a/server/core/monitor.c +++ b/server/core/monitor.c @@ -41,8 +41,24 @@ #include #include #include +#include +#include #include +/* + * Create declarations of the enum for monitor events and also the array of + * structs containing the matching names. The data is taken from def_monitor_event.h + * + */ + +#undef ADDITEM +#define ADDITEM( _event_type, _event_name ) { #_event_name } +const monitor_def_t monitor_event_definitions[MAX_MONITOR_EVENT] = +{ +#include "def_monitor_event.h" +}; +#undef ADDITEM + static MONITOR *allMonitors = NULL; static SPINLOCK monLock = SPINLOCK_INIT; @@ -348,7 +364,7 @@ monitorSetInterval (MONITOR *mon, unsigned long interval) */ void monitorSetNetworkTimeout(MONITOR *mon, int type, int value) { - + int max_timeout = (int)(mon->interval/1000); int new_timeout = max_timeout -1; @@ -549,3 +565,363 @@ void monitorAddParameters(MONITOR *monitor, CONFIG_PARAMETER *params) params = params->next; } } + +/** + * 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; +} + +/* + * Determine a monitor event, defined by the difference between the old + * status of a server and the new status. + * + * @param node The monitor server data for a particular server + * @result monitor_event_t A monitor event (enum) + */ +monitor_event_t +mon_get_event_type(MONITOR_SERVERS* node) +{ + typedef enum { + DOWN_EVENT, + UP_EVENT, + LOSS_EVENT, + NEW_EVENT, + UNSUPPORTED_EVENT + } general_event_type; + general_event_type event_type = UNSUPPORTED_EVENT; + + unsigned int prev = node->mon_prev_status + & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB); + unsigned int present = node->server->status + & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB); + + if (prev == present) + { + /* No change in the bits we're interested in */ + return UNDEFINED_MONITOR_EVENT; + } + + if ((prev & SERVER_RUNNING) == 0) + { + /* The server was not running previously */ + if ((present & SERVER_RUNNING) != 0) + { + event_type = UP_EVENT; + } + /* Otherwise, was not running and still is not running */ + /* - this is not a recognised event */ + } + else + { + /* Previous state must have been running */ + if ((present & SERVER_RUNNING) == 0) + { + event_type = DOWN_EVENT; + } + else + { + /* Was running and still is */ + if (prev & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) + { + /* We used to know what kind of server it was */ + event_type = LOSS_EVENT; + } + else + { + /* We didn't know what kind of server it was, now we do*/ + event_type = NEW_EVENT; + } + } + } + + switch (event_type) + { + case UP_EVENT: + return (present & SERVER_MASTER) ? MASTER_UP_EVENT : + (present & SERVER_SLAVE) ? SLAVE_UP_EVENT : + (present & SERVER_JOINED) ? SYNCED_UP_EVENT : + (present & SERVER_NDB) ? NDB_UP_EVENT : + SERVER_UP_EVENT; + case DOWN_EVENT: + return (prev & SERVER_MASTER) ? MASTER_DOWN_EVENT : + (prev & SERVER_SLAVE) ? SLAVE_DOWN_EVENT : + (prev & SERVER_JOINED) ? SYNCED_DOWN_EVENT : + (prev & SERVER_NDB) ? NDB_DOWN_EVENT : + SERVER_DOWN_EVENT; + case LOSS_EVENT: + return (prev & SERVER_MASTER) ? LOST_MASTER_EVENT : + (prev & SERVER_SLAVE) ? LOST_SLAVE_EVENT : + (prev & SERVER_JOINED) ? LOST_SYNCED_EVENT : + LOST_NDB_EVENT; + case NEW_EVENT: + return (present & SERVER_MASTER) ? NEW_MASTER_EVENT : + (present & SERVER_SLAVE) ? NEW_SLAVE_EVENT : + (present & SERVER_JOINED) ? NEW_SYNCED_EVENT : + NEW_NDB_EVENT; + default: + return UNDEFINED_MONITOR_EVENT; + } +} + +/* + * Given a monitor event (enum) provide a text string equivalent + * @param node The monitor server data whose event is wanted + * @result string The name of the monitor event for the server + */ +const char* +mon_get_event_name(MONITOR_SERVERS* node) +{ + return monitor_event_definitions[mon_get_event_type(node)].name; +} + +/* + * Given the text version of a monitor event, determine the event (enum) + * + * @param event_name String containing the event name + * @result monitor_event_t Monitor event corresponding to name + */ +monitor_event_t +mon_name_to_event (const char *event_name) +{ + monitor_event_t event; + + for (event = 0; event < MAX_MONITOR_EVENT; event++) + { + if (0 == strcasecmp(monitor_event_definitions[event].name, event_name)) + { + return event; + } + } + return UNDEFINED_MONITOR_EVENT; +} + +/** + * Create a list of running servers + * + * @param servers Monitored servers + * @param dest Destination where the string is appended, must be null terminated + * @param len Length of @c dest + */ +void +mon_append_node_names(MONITOR_SERVERS* servers, char* dest, int len) +{ + char *separator = ""; + char arr[MAX_SERVER_NAME_LEN + 32]; // Some extra space for port + + while (servers && strlen(dest) < (len - strlen(separator))) + { + if (SERVER_IS_RUNNING(servers->server)) + { + strcat(dest, separator); + separator = ","; + snprintf(arr, sizeof(arr), "%s:%d", servers->server->name, servers->server->port); + strncat(dest, arr, len - strlen(dest) - 1); + } + servers = servers->next; + } +} + +/** + * 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) +{ + /* Previous status is -1 if not yet set */ + return (mon_srv->mon_prev_status != -1 + && mon_srv->mon_prev_status != mon_srv->server->status); +} + +/** + * 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) +{ + return (SERVER_IS_DOWN(mon_srv->server) && mon_srv->mon_err_count == 0); +} + +/** + * Launch a script + * @param mon Owning monitor + * @param ptr The server which has changed state + * @param script Script to execute + */ +void +monitor_launch_script(MONITOR* mon, MONITOR_SERVERS* ptr, char* script) +{ + char nodelist[PATH_MAX + MON_ARG_MAX + 1] = {'\0'}; + char initiator[strlen(ptr->server->name) + 24]; // Extra space for port + + snprintf(initiator, sizeof(initiator), "%s:%d", ptr->server->name, ptr->server->port); + mon_append_node_names(mon->databases, nodelist, PATH_MAX + MON_ARG_MAX); + + EXTERNCMD* cmd = externcmd_allocate(script); + + if (cmd == NULL) + { + MXS_ERROR("Failed to initialize script: %s", script); + return; + } + + externcmd_substitute_arg(cmd, "[$]INITIATOR", initiator); + externcmd_substitute_arg(cmd, "[$]EVENT", mon_get_event_name(ptr)); + externcmd_substitute_arg(cmd, "[$]NODELIST", nodelist); + + if (externcmd_execute(cmd)) + { + MXS_ERROR("Failed to execute script " + "'%s' on server state change event %s.", + script, mon_get_event_name(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* given_string) +{ + char *tok, *saved, *string = strdup(given_string); + monitor_event_t event; + + tok = strtok_r(string, ",| ", &saved); + + if (tok == NULL) + { + free(string); + return -1; + } + + while (tok) + { + event = mon_name_to_event(tok); + if (event == UNDEFINED_MONITOR_EVENT) + { + MXS_ERROR("Invalid event name %s", tok); + free(string); + return -1; + } + if (event < count) + { + events[event] = true; + tok = strtok_r(NULL, ",| ", &saved); + } + } + + free(string); + return 0; +} + +/** + * Connect to a database. This will always leave a valid database handle in the + * database->con pointer. This allows the user to call MySQL C API functions to + * find out the reason of the failure. + * @param mon Monitor + * @param database Monitored database + * @return MONITOR_CONN_OK if the connection is OK else the reason for the failure + */ +connect_result_t +mon_connect_to_db(MONITOR* mon, MONITOR_SERVERS *database) +{ + connect_result_t rval = MONITOR_CONN_OK; + + /** Return if the connection is OK */ + if (database->con && mysql_ping(database->con) == 0) + { + return rval; + } + + int connect_timeout = mon->connect_timeout; + int read_timeout = mon->read_timeout; + int write_timeout = mon->write_timeout; + char *uname = database->server->monuser ? database->server->monuser : mon->user; + char *passwd = database->server->monpw ? database->server->monpw : mon->password; + char *dpwd = decryptPassword(passwd); + + if (database->con) + { + mysql_close(database->con); + } + database->con = mysql_init(NULL); + + mysql_options(database->con, MYSQL_OPT_CONNECT_TIMEOUT, (void *) &connect_timeout); + mysql_options(database->con, MYSQL_OPT_READ_TIMEOUT, (void *) &read_timeout); + mysql_options(database->con, MYSQL_OPT_WRITE_TIMEOUT, (void *) &write_timeout); + + time_t start = time(NULL); + bool result = (mysql_real_connect(database->con, + database->server->name, + uname, + dpwd, + NULL, + database->server->port, + NULL, + 0) != NULL); + time_t end = time(NULL); + + if (!result) + { + if ((int) difftime(end, start) >= connect_timeout) + { + rval = MONITOR_CONN_TIMEOUT; + } + else + { + rval = MONITOR_CONN_REFUSED; + } + } + + free(dpwd); + return rval; +} + +/** + * Log an error about the failure to connect to a backend server + * and why it happened. + * @param database Backend database + * @param rval Return value of mon_connect_to_db + */ +void +mon_log_connect_error(MONITOR_SERVERS* database, connect_result_t rval) +{ + MXS_ERROR(rval == MONITOR_CONN_TIMEOUT ? + "Monitor timed out when connecting to " + "server %s:%d : \"%s\"" : + "Monitor was unable to connect to " + "server %s:%d : \"%s\"", + database->server->name, + database->server->port, + mysql_error(database->con)); +} diff --git a/server/core/server.c b/server/core/server.c index 8623eaa2e..f67034308 100644 --- a/server/core/server.c +++ b/server/core/server.c @@ -30,7 +30,7 @@ * 28/05/14 Massimiliano Pinto Addition of rlagd and node_ts fields * 20/06/14 Massimiliano Pinto Addition of master_id, depth, slaves fields * 26/06/14 Mark Riddoch Addition of server parameters - * 30/08/14 Massimiliano Pinto Addition of new service status description + * 30/08/14 Massimiliano Pinto Addition of new service status description * 30/10/14 Massimiliano Pinto Addition of SERVER_MASTER_STICKINESS description * 01/06/15 Massimiliano Pinto Addition of server_update_address/port * 19/06/15 Martin Brampton Extra code for persistent connections @@ -149,20 +149,20 @@ DCB * server_get_persistent(SERVER *server, char *user, const char *protocol) { DCB *dcb, *previous = NULL; - - if (server->persistent - && dcb_persistent_clean_count(server->persistent, false) + + if (server->persistent + && dcb_persistent_clean_count(server->persistent, false) && server->persistent && (server->status & SERVER_RUNNING)) { spinlock_acquire(&server->persistlock); dcb = server->persistent; while (dcb) { - if (dcb->user - && dcb->protoname + if (dcb->user + && dcb->protoname && !dcb-> dcb_errhandle_called && !(dcb->flags & DCBF_HUNG) - && 0 == strcmp(dcb->user, user) + && 0 == strcmp(dcb->user, user) && 0 == strcmp(dcb->protoname, protocol)) { if (NULL == previous) @@ -562,7 +562,7 @@ spin_reporter(void *dcb, char *desc, int value) * @param pdcb DCB to print results to * @param server SERVER for which DCBs are to be printed */ -void +void dprintPersistentDCBs(DCB *pdcb, SERVER *server) { DCB *dcb; @@ -666,14 +666,36 @@ void server_set_status(SERVER *server, int bit) { server->status |= bit; - + /** clear error logged flag before the next failure */ - if (SERVER_IS_MASTER(server)) + if (SERVER_IS_MASTER(server)) { server->master_err_is_logged = false; } } +/** + * Set one or more status bit(s) from a specified set, clearing any others + * in the specified set + * + * @param server The server to update + * @param bit The bit to set for the server + */ +void +server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set) +{ + /** clear error logged flag before the next failure */ + if ((bits_to_set & SERVER_MASTER) && ((server->status & SERVER_MASTER) == 0)) + { + server->master_err_is_logged = false; + } + + if ((server->status & specified_bits) != bits_to_set) + { + server->status = (server->status & ~specified_bits) | bits_to_set; + } +} + /** * Clear a status bit in the server * @@ -686,6 +708,18 @@ server_clear_status(SERVER *server, int bit) server->status &= ~bit; } +/** + * Transfer status bitstring from one server to another + * + * @param dest_server The server to be updated + * @param source_server The server to provide the new bit string + */ +void +server_transfer_status(SERVER *dest_server, SERVER *source_server) +{ + dest_server->status = source_server->status; +} + /** * Add a user name and password to use for monitoring the * state of the server. diff --git a/server/include/def_monitor_event.h b/server/include/def_monitor_event.h new file mode 100644 index 000000000..9477acf06 --- /dev/null +++ b/server/include/def_monitor_event.h @@ -0,0 +1,51 @@ +/* + * 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-2014 + */ + +/** + * @file def_monitor_event.h + * + * @verbatim + * Revision History + * + * Date Who Description + * 01-06-2013 Martin Brampton Initial implementation + */ + +ADDITEM( UNDEFINED_MONITOR_EVENT, undefined ), +ADDITEM( MASTER_DOWN_EVENT, master_down ), +ADDITEM( MASTER_UP_EVENT, master_up ), +ADDITEM( SLAVE_DOWN_EVENT, slave_down ), +ADDITEM( SLAVE_UP_EVENT, slave_up ), +ADDITEM( SERVER_DOWN_EVENT, server_down ), +ADDITEM( SERVER_UP_EVENT, server_up ), +ADDITEM( SYNCED_DOWN_EVENT, synced_down ), +ADDITEM( SYNCED_UP_EVENT, synced_up ), +ADDITEM( DONOR_DOWN_EVENT, donor_down ), +ADDITEM( DONOR_UP_EVENT, donor_up ), +ADDITEM( NDB_DOWN_EVENT, ndb_down ), +ADDITEM( NDB_UP_EVENT, ndb_up ), +ADDITEM( LOST_MASTER_EVENT, lost_master ), +ADDITEM( LOST_SLAVE_EVENT, lost_slave ), +ADDITEM( LOST_SYNCED_EVENT, lost_synced ), +ADDITEM( LOST_DONOR_EVENT, lost_donor ), +ADDITEM( LOST_NDB_EVENT, lost_ndb ), +ADDITEM( NEW_MASTER_EVENT, new_master ), +ADDITEM( NEW_SLAVE_EVENT, new_slave ), +ADDITEM( NEW_SYNCED_EVENT, new_synced ), +ADDITEM( NEW_DONOR_EVENT, new_donor ), +ADDITEM( NEW_NDB_EVENT, new_ndb ), diff --git a/server/include/monitor.h b/server/include/monitor.h index 5c2bb1f69..f0601ee3e 100644 --- a/server/include/monitor.h +++ b/server/include/monitor.h @@ -20,8 +20,11 @@ #include #include #include +#include #include #include +#include +#include /** * @file monitor.h The interface to the monitor module @@ -39,6 +42,8 @@ * 30/10/14 Massimiliano Pinto Addition of disableMasterFailback * 07/11/14 Massimiliano Pinto Addition of setNetworkTimeout * 19/02/15 Mark Riddoch Addition of monitorGetList + * 19/11/15 Martin Brampton Automation of event and name declaration, absorption + * of what was formerly monitor_common.h * * @endverbatim */ @@ -46,18 +51,18 @@ /** * The "Module Object" for a monitor module. * - * The monitor modules are designed to monitor the backend databases that the gateway + * The monitor modules are designed to monitor the backend databases that the gateway * connects to and provide information regarding the status of the databases that * is used in the routing decisions. * * startMonitor is called to start the monitoring process, it is called on the main * thread of the gateway and is responsible for creating a thread for the monitor - * itself to run on. This should use the entry points defined in the thread.h + * itself to run on. This should use the entry points defined in the thread.h * header file rather than make direct calls to the operating system thrading libraries. * The return from startMonitor is a void * handle that will be passed to all other monitor * API calls. * - * stopMonitor is responsible for shuting down and destroying a monitor, it is called + * stopMonitor is responsible for shuting down and destroying a monitor, it is called * with the void * handle that was returned by startMonitor. * * registerServer is called to register a server that must be monitored with a running @@ -86,7 +91,7 @@ typedef struct { /** * Monitor state bit mask values */ -typedef enum +typedef enum { MONITOR_STATE_ALLOC = 0x00, MONITOR_STATE_RUNNING = 0x01, @@ -105,6 +110,18 @@ typedef enum MONITOR_WRITE_TIMEOUT = 2 } monitor_timeouts_t; +/* + * Results of attempt at database connection for monitoring + */ +typedef enum +{ + MONITOR_CONN_OK, + MONITOR_CONN_REFUSED, + MONITOR_CONN_TIMEOUT +} connect_result_t; + +#define MON_ARG_MAX 8192 + #define DEFAULT_CONNECT_TIMEOUT 3 #define DEFAULT_READ_TIMEOUT 1 #define DEFAULT_WRITE_TIMEOUT 2 @@ -118,6 +135,25 @@ typedef enum #define MONITOR_DEFAULT_ID 1UL // unsigned long value #define MONITOR_MAX_NUM_SLAVES 20 //number of MySQL slave servers associated to a MySQL master server +/* + * Create declarations of the enum for monitor events and also the array of + * structs containing the matching names. The data is taken from def_monitor_event.h + */ +#undef ADDITEM +#define ADDITEM( _event_type, _event_name ) _event_type +typedef enum +{ +#include "def_monitor_event.h" + MAX_MONITOR_EVENT +} monitor_event_t; +#undef ADDITEM + +typedef struct monitor_def_s +{ + char name[30]; +} monitor_def_t; + +extern const monitor_def_t monitor_event_definitions[]; /** * The linked list of servers that are being monitored by the monitor module. @@ -175,4 +211,17 @@ extern void monitorSetNetworkTimeout(MONITOR *, int, int); extern RESULTSET *monitorGetList(); bool check_monitor_permissions(MONITOR* monitor); +monitor_event_t mon_name_to_event(const char* tok); +void mon_append_node_names(MONITOR_SERVERS* start, char* str, int len); +monitor_event_t mon_get_event_type(MONITOR_SERVERS* node); +const char* mon_get_event_name(MONITOR_SERVERS* node); +void monitor_clear_pending_status(MONITOR_SERVERS *ptr, int bit); +void monitor_set_pending_status(MONITOR_SERVERS *ptr, int bit); +bool mon_status_changed(MONITOR_SERVERS* mon_srv); +bool mon_print_fail_status(MONITOR_SERVERS* mon_srv); +void monitor_launch_script(MONITOR* mon, MONITOR_SERVERS* ptr, char* script); +int mon_parse_event_string(bool* events, size_t count, char* string); +connect_result_t mon_connect_to_db(MONITOR* mon, MONITOR_SERVERS *database); +void mon_log_connect_error(MONITOR_SERVERS* database, connect_result_t rval); + #endif diff --git a/server/include/server.h b/server/include/server.h index 84151ccad..99b4e0555 100644 --- a/server/include/server.h +++ b/server/include/server.h @@ -150,12 +150,12 @@ typedef struct server { (SERVER_RUNNING|SERVER_MASTER)) /** - * Is the server valid candidate for root master. The server must be running, + * Is the server valid candidate for root master. The server must be running, * marked as master and not have maintenance bit set. */ #define SERVER_IS_ROOT_MASTER(server) \ (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_MASTER)) - + /** * Is the server a slave? The server must be both running and marked as a slave * in order for the macro to return true @@ -164,7 +164,7 @@ typedef struct server { (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_SLAVE)) /** - * Is the server joined Galera node? The server must be running and joined. + * Is the server joined Galera node? The server must be running and joined. */ #define SERVER_IS_JOINED(server) \ (((server)->status & (SERVER_RUNNING|SERVER_JOINED|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_JOINED)) @@ -176,7 +176,7 @@ typedef struct server { (((server)->status & (SERVER_RUNNING|SERVER_NDB|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_NDB)) /** - * Is the server in maintenance mode. + * Is the server in maintenance mode. */ #define SERVER_IN_MAINT(server) ((server)->status & SERVER_MAINT) @@ -200,8 +200,10 @@ extern void dprintServer(DCB *, SERVER *); extern void dprintPersistentDCBs(DCB *, SERVER *); extern void dListServers(DCB *); extern char *server_status(SERVER *); +extern void server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set); extern void server_set_status(SERVER *, int); extern void server_clear_status(SERVER *, int); +extern void server_transfer_status(SERVER *dest_server, SERVER *source_server); extern void serverAddMonUser(SERVER *, char *, char *); extern void serverAddParameter(SERVER *, char *, char *); extern char *serverGetParameter(SERVER *, char *); diff --git a/server/modules/monitor/CMakeLists.txt b/server/modules/monitor/CMakeLists.txt index 58a59e1e1..b291b83b5 100644 --- a/server/modules/monitor/CMakeLists.txt +++ b/server/modules/monitor/CMakeLists.txt @@ -1,20 +1,20 @@ -add_library(mysqlmon SHARED mysql_mon.c monitor_common.c) +add_library(mysqlmon SHARED mysql_mon.c) target_link_libraries(mysqlmon log_manager) add_dependencies(mysqlmon pcre2) install(TARGETS mysqlmon DESTINATION ${MAXSCALE_LIBDIR}) -add_library(galeramon SHARED galeramon.c monitor_common.c) +add_library(galeramon SHARED galeramon.c) target_link_libraries(galeramon log_manager) add_dependencies(galeramon pcre2) install(TARGETS galeramon DESTINATION ${MAXSCALE_LIBDIR}) -add_library(ndbclustermon SHARED ndbclustermon.c monitor_common.c) +add_library(ndbclustermon SHARED ndbclustermon.c) target_link_libraries(ndbclustermon log_manager) add_dependencies(ndbclustermon pcre2) install(TARGETS ndbclustermon DESTINATION ${MAXSCALE_LIBDIR}) if(BUILD_MMMON) - add_library(mmmon SHARED mmmon.c monitor_common.c) + add_library(mmmon SHARED mmmon.c) target_link_libraries(mmmon log_manager) add_dependencies(mmmon pcre2) install(TARGETS mmmon DESTINATION ${MAXSCALE_LIBDIR}) diff --git a/server/modules/monitor/galeramon.c b/server/modules/monitor/galeramon.c index dbfef270b..9750df215 100644 --- a/server/modules/monitor/galeramon.c +++ b/server/modules/monitor/galeramon.c @@ -24,7 +24,7 @@ * * Date Who Description * 22/07/13 Mark Riddoch Initial implementation - * 21/05/14 Massimiliano Pinto Monitor sets a master server + * 21/05/14 Massimiliano Pinto Monitor sets a master server * that has the lowest value of wsrep_local_index * 23/05/14 Massimiliano Pinto Added 1 configuration option (setInterval). * Interval is printed in diagnostics. @@ -267,7 +267,9 @@ diagnostics(DCB *dcb, void *arg) } /** - * Monitor an individual server + * Monitor an individual server. Does not deal with the setting of master or + * slave bits, except for clearing them when a server is not joined to the + * cluster. * * @param handle The MySQL Monitor object * @param database The database to probe @@ -281,6 +283,7 @@ monitorDatabase(MONITOR *mon, MONITOR_SERVERS *database) int isjoined = 0; unsigned long int server_version = 0; char *server_string; + SERVER temp_server; /* Don't even probe server flagged as in maintenance */ if (SERVER_IN_MAINT(database->server)) @@ -289,24 +292,21 @@ monitorDatabase(MONITOR *mon, MONITOR_SERVERS *database) /** Store previous status */ database->mon_prev_status = database->server->status; - server_clear_status(database->server, SERVER_RUNNING); - - /* Also clear Joined, M/S and Stickiness bits */ - server_clear_status(database->server, SERVER_JOINED); - server_clear_status(database->server, SERVER_SLAVE); - server_clear_status(database->server, SERVER_MASTER); - server_clear_status(database->server, SERVER_MASTER_STICKINESS); + server_transfer_status(&temp_server, database->server); + server_clear_status(&temp_server, SERVER_RUNNING); + /* Also clear Joined */ + server_clear_status(&temp_server, SERVER_JOINED); connect_result_t rval = mon_connect_to_db(mon, database); if (rval != MONITOR_CONN_OK) { if (mysql_errno(database->con) == ER_ACCESS_DENIED_ERROR) { - server_set_status(database->server, SERVER_AUTH_ERROR); + server_set_status(&temp_server, SERVER_AUTH_ERROR); } else { - server_clear_status(database->server, SERVER_AUTH_ERROR); + server_clear_status(&temp_server, SERVER_AUTH_ERROR); } database->server->node_id = -1; @@ -320,7 +320,7 @@ monitorDatabase(MONITOR *mon, MONITOR_SERVERS *database) } /* If we get this far then we have a working connection */ - server_set_status(database->server, SERVER_RUNNING); + server_set_status(&temp_server, SERVER_RUNNING); /* get server version string */ server_string = (char *) mysql_get_server_info(database->con); @@ -404,12 +404,27 @@ monitorDatabase(MONITOR *mon, MONITOR_SERVERS *database) if (isjoined) { - server_set_status(database->server, SERVER_JOINED); + server_set_status(&temp_server, SERVER_JOINED); } else { - server_clear_status(database->server, SERVER_JOINED); + server_clear_status(&temp_server, SERVER_JOINED); } + + /* clear bits for non member nodes */ + if (!SERVER_IN_MAINT(database->server) && (!SERVER_IS_JOINED(&temp_server))) + { + database->server->depth = -1; + + /* clear M/S status */ + server_clear_status(&temp_server, SERVER_SLAVE); + server_clear_status(&temp_server, SERVER_MASTER); + + /* clear master sticky status */ + server_clear_status(&temp_server, SERVER_MASTER_STICKINESS); + } + + server_transfer_status(database->server, &temp_server); } /** @@ -452,9 +467,9 @@ monitorMain(void *arg) } /** Wait base interval */ thread_millisleep(MON_BASE_INTERVAL_MS); - /** - * Calculate how far away the monitor interval is from its full - * cycle and if monitor interval time further than the base + /** + * Calculate how far away the monitor interval is from its full + * cycle and if monitor interval time further than the base * interval, then skip monitoring checks. Excluding the first * round. */ @@ -478,19 +493,6 @@ monitorMain(void *arg) monitorDatabase(mon, ptr); - /* clear bits for non member nodes */ - if (!SERVER_IN_MAINT(ptr->server) && (!SERVER_IS_JOINED(ptr->server))) - { - ptr->server->depth = -1; - - /* clear M/S status */ - server_clear_status(ptr->server, SERVER_SLAVE); - server_clear_status(ptr->server, SERVER_MASTER); - - /* clear master sticky status */ - server_clear_status(ptr->server, SERVER_MASTER_STICKINESS); - } - /* Log server status change */ if (mon_status_changed(ptr)) { @@ -556,28 +558,24 @@ monitorMain(void *arg) { if (ptr != handle->master) { - /* set the Slave role */ - server_set_status(ptr->server, SERVER_SLAVE); - server_clear_status(ptr->server, SERVER_MASTER); - - /* clear master stickiness */ - server_clear_status(ptr->server, SERVER_MASTER_STICKINESS); + /* set the Slave role and clear master stickiness */ + server_clear_set_status(ptr->server, (SERVER_SLAVE|SERVER_MASTER|SERVER_MASTER_STICKINESS), SERVER_SLAVE); } else { - /* set the Master role */ - server_set_status(handle->master->server, SERVER_MASTER); - server_clear_status(handle->master->server, SERVER_SLAVE); - if (candidate_master && handle->master->server->node_id != candidate_master->server->node_id) { - /* set master stickiness */ - server_set_status(handle->master->server, SERVER_MASTER_STICKINESS); + /* set master role and master stickiness */ + server_clear_set_status(ptr->server, + (SERVER_SLAVE|SERVER_MASTER|SERVER_MASTER_STICKINESS), + (SERVER_MASTER|SERVER_MASTER_STICKINESS)); } else { - /* clear master stickiness */ - server_clear_status(ptr->server, SERVER_MASTER_STICKINESS); + /* set master role and clear master stickiness */ + server_clear_set_status(ptr->server, + (SERVER_SLAVE|SERVER_MASTER|SERVER_MASTER_STICKINESS), + SERVER_MASTER); } } } diff --git a/server/modules/monitor/galeramon.h b/server/modules/monitor/galeramon.h index b92e97015..d4cf3b94c 100644 --- a/server/modules/monitor/galeramon.h +++ b/server/modules/monitor/galeramon.h @@ -22,7 +22,6 @@ #include #include #include -#include #include #include #include diff --git a/server/modules/monitor/mmmon.h b/server/modules/monitor/mmmon.h index 9e1f4d962..923a4b182 100644 --- a/server/modules/monitor/mmmon.h +++ b/server/modules/monitor/mmmon.h @@ -32,7 +32,6 @@ #include #include #include -#include #include /** diff --git a/server/modules/monitor/monitor_common.c b/server/modules/monitor/monitor_common.c deleted file mode 100644 index 4a56056ba..000000000 --- a/server/modules/monitor/monitor_common.c +++ /dev/null @@ -1,558 +0,0 @@ -/* - * 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 -#include - -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"; - - } - - -} - -/** - * Create a list of running servers - * @param start Monitored servers - * @param dest Destination where the string is formed - * @param len Length of @c dest - */ -void mon_append_node_names(MONITOR_SERVERS* start, char* dest, int len) -{ - MONITOR_SERVERS* ptr = start; - bool first = true; - int slen = strlen(dest); - char arr[MAX_SERVER_NAME_LEN + 32]; // Some extra space for port - while (ptr && slen < len) - { - if (SERVER_IS_RUNNING(ptr->server)) - { - if (!first) - { - strncat(dest, ",", len); - } - first = false; - snprintf(arr, sizeof(arr), "%s:%d", ptr->server->name, ptr->server->port); - strncat(dest, arr, len); - slen = strlen(dest); - } - ptr = ptr->next; - } -} - -/** - * 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; -} - -/** - * Launch a script - * @param mon Owning monitor - * @param ptr The server which has changed state - * @param script Script to execute - */ -void monitor_launch_script(MONITOR* mon, MONITOR_SERVERS* ptr, char* script) -{ - char nodelist[PATH_MAX + MON_ARG_MAX + 1] = {'\0'}; - char initiator[strlen(ptr->server->name) + 24]; // Extra space for port - - snprintf(initiator, sizeof(initiator), "%s:%d", ptr->server->name, ptr->server->port); - mon_append_node_names(mon->databases, nodelist, PATH_MAX + MON_ARG_MAX); - - EXTERNCMD* cmd = externcmd_allocate(script); - - if (cmd == NULL) - { - MXS_ERROR("Failed to initialize script: %s", script); - return; - } - - externcmd_substitute_arg(cmd, "[$]INITIATOR", initiator); - externcmd_substitute_arg(cmd, "[$]EVENT", mon_get_event_name(ptr)); - externcmd_substitute_arg(cmd, "[$]NODELIST", nodelist); - - if (externcmd_execute(cmd)) - { - MXS_ERROR("Failed to execute script " - "'%s' on server state change event %s.", - script, mon_get_event_name(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) - { - MXS_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; - } - - return UNDEFINED_MONITOR_EVENT; -} - -/** - * Connect to a database. This will always leave a valid database handle in the - * database->con pointer. This allows the user to call MySQL C API functions to - * find out the reason of the failure. - * @param mon Monitor - * @param database Monitored database - * @return MONITOR_CONN_OK if the connection is OK else the reason for the failure - */ -connect_result_t mon_connect_to_db(MONITOR* mon, MONITOR_SERVERS *database) -{ - connect_result_t rval = MONITOR_CONN_OK; - - /** Return if the connection is OK */ - if (database->con && mysql_ping(database->con) == 0) - { - return rval; - } - - int connect_timeout = mon->connect_timeout; - int read_timeout = mon->read_timeout; - int write_timeout = mon->write_timeout; - char *uname = database->server->monuser ? database->server->monuser : mon->user; - char *passwd = database->server->monpw ? database->server->monpw : mon->password; - char *dpwd = decryptPassword(passwd); - - if (database->con) - { - mysql_close(database->con); - } - database->con = mysql_init(NULL); - - mysql_options(database->con, MYSQL_OPT_CONNECT_TIMEOUT, (void *) &connect_timeout); - mysql_options(database->con, MYSQL_OPT_READ_TIMEOUT, (void *) &read_timeout); - mysql_options(database->con, MYSQL_OPT_WRITE_TIMEOUT, (void *) &write_timeout); - - time_t start = time(NULL); - bool result = (mysql_real_connect(database->con, - database->server->name, - uname, - dpwd, - NULL, - database->server->port, - NULL, - 0) != NULL); - time_t end = time(NULL); - - if (!result) - { - if ((int) difftime(end, start) >= connect_timeout) - { - rval = MONITOR_CONN_TIMEOUT; - } - else - { - rval = MONITOR_CONN_REFUSED; - } - } - - free(dpwd); - return rval; -} - -/** - * Log an error about the failure to connect to a backend server - * and why it happened. - * @param database Backend database - * @param rval Return value of mon_connect_to_db - */ -void mon_log_connect_error(MONITOR_SERVERS* database, connect_result_t rval) -{ - if (rval == MONITOR_CONN_TIMEOUT) - { - MXS_ERROR("Monitor timed out when connecting to " - "server %s:%d : \"%s\"", - database->server->name, - database->server->port, - mysql_error(database->con)); - } - else - { - MXS_ERROR("Monitor was unable to connect to " - "server %s:%d : \"%s\"", - database->server->name, - database->server->port, - mysql_error(database->con)); - } -} diff --git a/server/modules/monitor/monitor_common.h b/server/modules/monitor/monitor_common.h deleted file mode 100644 index 13b191001..000000000 --- a/server/modules/monitor/monitor_common.h +++ /dev/null @@ -1,87 +0,0 @@ -#ifndef _MONITOR_COMMON_HG -#define _MONITOR_COMMON_HG -/* - * 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 -#include -#include -#include -#include -#include -/** - * @file monitor_common.h - The generic monitor structures all monitors use - * - * Revision History - * - * Date Who Description - * 07/05/15 Markus Makela Initial Implementation - * @endverbatim - */ - -#define MON_ARG_MAX 8192 - -/** Monitor events that are caused by servers moving from - * one state to another.*/ -typedef enum -{ - UNDEFINED_MONITOR_EVENT, - MASTER_DOWN_EVENT, - MASTER_UP_EVENT, - SLAVE_DOWN_EVENT, - SLAVE_UP_EVENT, - SERVER_DOWN_EVENT, - SERVER_UP_EVENT, - SYNCED_DOWN_EVENT, - SYNCED_UP_EVENT, - DONOR_DOWN_EVENT, - DONOR_UP_EVENT, - NDB_DOWN_EVENT, - NDB_UP_EVENT, - LOST_MASTER_EVENT, - LOST_SLAVE_EVENT, - LOST_SYNCED_EVENT, - LOST_DONOR_EVENT, - LOST_NDB_EVENT, - NEW_MASTER_EVENT, - NEW_SLAVE_EVENT, - NEW_SYNCED_EVENT, - NEW_DONOR_EVENT, - NEW_NDB_EVENT, - MAX_MONITOR_EVENT -} monitor_event_t; - -typedef enum -{ - MONITOR_CONN_OK, - MONITOR_CONN_REFUSED, - MONITOR_CONN_TIMEOUT -} connect_result_t; - -void mon_append_node_names(MONITOR_SERVERS* start, char* str, int len); -monitor_event_t mon_get_event_type(MONITOR_SERVERS* node); -char* mon_get_event_name(MONITOR_SERVERS* node); -void monitor_clear_pending_status(MONITOR_SERVERS *ptr, int bit); -void monitor_set_pending_status(MONITOR_SERVERS *ptr, int bit); -bool mon_status_changed(MONITOR_SERVERS* mon_srv); -bool mon_print_fail_status(MONITOR_SERVERS* mon_srv); -void monitor_launch_script(MONITOR* mon, MONITOR_SERVERS* ptr, char* script); -int mon_parse_event_string(bool* events, size_t count, char* string); -connect_result_t mon_connect_to_db(MONITOR* mon, MONITOR_SERVERS *database); -void mon_log_connect_error(MONITOR_SERVERS* database, connect_result_t rval); -#endif diff --git a/server/modules/monitor/mysql_mon.c b/server/modules/monitor/mysql_mon.c index 2290978aa..886d6f534 100644 --- a/server/modules/monitor/mysql_mon.c +++ b/server/modules/monitor/mysql_mon.c @@ -919,7 +919,7 @@ monitorMain(void *arg) /* log it once */ if (mon_status_changed(ptr)) { - MXS_NOTICE("[mysql_mon]: root server " + MXS_WARNING("[mysql_mon]: root server " "[%s:%i] is no longer Master," " let's use it again even " " if it could be a stale master," diff --git a/server/modules/monitor/mysqlmon.h b/server/modules/monitor/mysqlmon.h index eaa640a94..b23877aa8 100644 --- a/server/modules/monitor/mysqlmon.h +++ b/server/modules/monitor/mysqlmon.h @@ -32,7 +32,6 @@ #include #include #include -#include #include /** diff --git a/server/modules/monitor/ndbclustermon.h b/server/modules/monitor/ndbclustermon.h index 90798fb87..e6d6e9575 100644 --- a/server/modules/monitor/ndbclustermon.h +++ b/server/modules/monitor/ndbclustermon.h @@ -32,7 +32,6 @@ #include #include #include -#include #include /** diff --git a/server/modules/routing/binlog/CMakeLists.txt b/server/modules/routing/binlog/CMakeLists.txt index 11ba80dcb..997754cf1 100644 --- a/server/modules/routing/binlog/CMakeLists.txt +++ b/server/modules/routing/binlog/CMakeLists.txt @@ -16,8 +16,8 @@ add_executable(maxbinlogcheck maxbinlogcheck.c blr_file.c blr_cache.c blr_master ${CMAKE_SOURCE_DIR}/server/core/resultset.c ${CMAKE_SOURCE_DIR}/server/core/load_utils.c ${CMAKE_SOURCE_DIR}/server/core/monitor.c ${CMAKE_SOURCE_DIR}/server/core/gw_utils.c ${CMAKE_SOURCE_DIR}/server/core/thread.c ${CMAKE_SOURCE_DIR}/server/core/secrets.c - ${CMAKE_SOURCE_DIR}/server/core/random_jkiss.c - ${CMAKE_SOURCE_DIR}/log_manager/log_manager.cc) + ${CMAKE_SOURCE_DIR}/server/core/random_jkiss.c ${CMAKE_SOURCE_DIR}/server/core/maxscale_pcre2.c + ${CMAKE_SOURCE_DIR}/log_manager/log_manager.cc ${CMAKE_SOURCE_DIR}/server/core/externcmd.c) target_link_libraries(maxbinlogcheck utils ssl pthread ${LZMA_LINK_FLAGS} ${EMBEDDED_LIB} ${PCRE_LINK_FLAGS} aio rt crypt dl crypto inih z m stdc++ ${CURL_LIBRARIES})