hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-1703: Move additional classes to separate file

Browse Source 
Also use stl containers in monitor definition.
This commit is contained in:
Esa Korhonen
2018-02-20 12:55:33 +02:00
parent 8ef1385d1a
commit 173f44b351
5 changed files with 364 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
server/modules/monitor/mariadbmon/CMakeLists.txt
View File

@ -1,4 +1,4 @@
add_library(mariadbmon SHARED mariadbmon.cc) add_library(mariadbmon SHARED mariadbmon.cc utilities.cc)
target_link_libraries(mariadbmon maxscale-common) target_link_libraries(mariadbmon maxscale-common)
add_dependencies(mariadbmon pcre2) add_dependencies(mariadbmon pcre2)
set_target_properties(mariadbmon PROPERTIES VERSION "1.4.0") set_target_properties(mariadbmon PROPERTIES VERSION "1.4.0")

407
server/modules/monitor/mariadbmon/mariadbmon.cc
View File

@ -35,6 +35,7 @@
#include <maxscale/utils.h> #include <maxscale/utils.h>
// TODO: For monitorAddParameters // TODO: For monitorAddParameters
#include "../../../core/internal/monitor.h" #include "../../../core/internal/monitor.h"
#include "utilities.hh"
/** Column positions for SHOW SLAVE STATUS */ /** Column positions for SHOW SLAVE STATUS */
#define MYSQL55_STATUS_MASTER_LOG_POS 5 #define MYSQL55_STATUS_MASTER_LOG_POS 5
@ -69,16 +70,9 @@
} while (false) } while (false)
using std::string; using std::string;
typedef std::vector<MXS_MONITORED_SERVER*> ServerVector;
typedef std::vector<string> StringVector; typedef std::vector<string> StringVector;
class MySqlServerInfo; class MySqlServerInfo;
class MariaDBMonitor;
enum mysql_server_version
{
MYSQL_SERVER_VERSION_100,
MYSQL_SERVER_VERSION_55,
MYSQL_SERVER_VERSION_51
};
enum slave_down_setting_t enum slave_down_setting_t
{ {
@ -101,36 +95,37 @@ static json_t* diagnostics_json(const MXS_MONITOR *);
static MXS_MONITORED_SERVER *getServerByNodeId(MXS_MONITORED_SERVER *, long); static MXS_MONITORED_SERVER *getServerByNodeId(MXS_MONITORED_SERVER *, long);
static MXS_MONITORED_SERVER *getSlaveOfNodeId(MXS_MONITORED_SERVER *, long, slave_down_setting_t); static MXS_MONITORED_SERVER *getSlaveOfNodeId(MXS_MONITORED_SERVER *, long, slave_down_setting_t);
static MXS_MONITORED_SERVER *get_replication_tree(MXS_MONITOR *, int); static MXS_MONITORED_SERVER *get_replication_tree(MXS_MONITOR *, int);
static void set_master_heartbeat(MYSQL_MONITOR *, MXS_MONITORED_SERVER *); static void set_master_heartbeat(MariaDBMonitor *, MXS_MONITORED_SERVER *);
static void set_slave_heartbeat(MXS_MONITOR *, MXS_MONITORED_SERVER *); static void set_slave_heartbeat(MXS_MONITOR *, MXS_MONITORED_SERVER *);
static int add_slave_to_master(long *, int, long); static int add_slave_to_master(long *, int, long);
static bool isMySQLEvent(mxs_monitor_event_t event); static bool isMySQLEvent(mxs_monitor_event_t event);
void check_maxscale_schema_replication(MXS_MONITOR *monitor); void check_maxscale_schema_replication(MXS_MONITOR *monitor);
static MySqlServerInfo* get_server_info(const MYSQL_MONITOR* handle, const MXS_MONITORED_SERVER* db); static MySqlServerInfo* get_server_info(MariaDBMonitor* handle, const MXS_MONITORED_SERVER* db);
static bool mon_process_failover(MYSQL_MONITOR*, uint32_t, bool*); static const MySqlServerInfo* get_server_info(const MariaDBMonitor* handle, const MXS_MONITORED_SERVER* db);
static bool do_failover(MYSQL_MONITOR* mon, json_t** output); static bool mon_process_failover(MariaDBMonitor*, uint32_t, bool*);
static bool do_switchover(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* current_master, static bool do_failover(MariaDBMonitor* mon, json_t** output);
static bool do_switchover(MariaDBMonitor* mon, MXS_MONITORED_SERVER* current_master,
MXS_MONITORED_SERVER* new_master, json_t** err_out); MXS_MONITORED_SERVER* new_master, json_t** err_out);
static bool update_gtids(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER *database, MySqlServerInfo* info); static bool update_gtids(MariaDBMonitor* mon, MXS_MONITORED_SERVER *database, MySqlServerInfo* info);
static bool update_replication_settings(MXS_MONITORED_SERVER *database, MySqlServerInfo* info); static bool update_replication_settings(MXS_MONITORED_SERVER *database, MySqlServerInfo* info);
static bool query_one_row(MXS_MONITORED_SERVER *database, const char* query, unsigned int expected_cols, static bool query_one_row(MXS_MONITORED_SERVER *database, const char* query, unsigned int expected_cols,
StringVector* output); StringVector* output);
static void read_server_variables(MXS_MONITORED_SERVER* database, MySqlServerInfo* serv_info); static void read_server_variables(MXS_MONITORED_SERVER* database, MySqlServerInfo* serv_info);
static bool server_is_rejoin_suspect(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* server, static bool server_is_rejoin_suspect(MariaDBMonitor* mon, MXS_MONITORED_SERVER* server,
MySqlServerInfo* master_info); MySqlServerInfo* master_info);
static bool get_joinable_servers(MYSQL_MONITOR* mon, ServerVector* output); static bool get_joinable_servers(MariaDBMonitor* mon, ServerVector* output);
static uint32_t do_rejoin(MYSQL_MONITOR* mon, const ServerVector& servers); static uint32_t do_rejoin(MariaDBMonitor* mon, const ServerVector& servers);
static bool join_cluster(MXS_MONITORED_SERVER* server, const char* change_cmd); static bool join_cluster(MXS_MONITORED_SERVER* server, const char* change_cmd);
static void disable_setting(MYSQL_MONITOR* mon, const char* setting); static void disable_setting(MariaDBMonitor* mon, const char* setting);
static bool cluster_can_be_joined(MYSQL_MONITOR* mon); static bool cluster_can_be_joined(MariaDBMonitor* mon);
static bool can_replicate_from(MYSQL_MONITOR* mon, static bool can_replicate_from(MariaDBMonitor* mon,
MXS_MONITORED_SERVER* slave, MySqlServerInfo* slave_info, MXS_MONITORED_SERVER* slave, MySqlServerInfo* slave_info,
MXS_MONITORED_SERVER* master, MySqlServerInfo* master_info); MXS_MONITORED_SERVER* master, MySqlServerInfo* master_info);
static bool wait_cluster_stabilization(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, static bool wait_cluster_stabilization(MariaDBMonitor* mon, MXS_MONITORED_SERVER* new_master,
const ServerVector& slaves, int seconds_remaining); const ServerVector& slaves, int seconds_remaining);
static string get_connection_errors(const ServerVector& servers); static string get_connection_errors(const ServerVector& servers);
static int64_t scan_server_id(const char* id_string); static int64_t scan_server_id(const char* id_string);
static string generate_change_master_cmd(MYSQL_MONITOR* mon, const string& master_host, int master_port); static string generate_change_master_cmd(MariaDBMonitor* mon, const string& master_host, int master_port);
static bool report_version_err = true; static bool report_version_err = true;
static const char* hb_table_name = "maxscale_schema.replication_heartbeat"; static const char* hb_table_name = "maxscale_schema.replication_heartbeat";
@ -160,185 +155,18 @@ static const char CN_REPLICATION_PASSWORD[] = "replication_password";
#define DEFAULT_MASTER_FAILURE_TIMEOUT "10" #define DEFAULT_MASTER_FAILURE_TIMEOUT "10"
/** Server id default value */ /** Server id default value */
static const int64_t SERVER_ID_UNKNOWN = -1; const int64_t SERVER_ID_UNKNOWN = -1;
/** Default port */ /** Default port */
static const int PORT_UNKNOWN = 0; const int PORT_UNKNOWN = 0;
class Gtid MariaDBMonitor::MariaDBMonitor()
{
public:
uint32_t domain;
int64_t server_id; // Is actually 32bit unsigned. 0 is only used by server versions <= 10.1
uint64_t sequence;
Gtid()
: domain(0)
, server_id(SERVER_ID_UNKNOWN)
, sequence(0)
{} {}
/** MariaDBMonitor::~MariaDBMonitor()
* Parse a Gtid-triplet from a string. In case of a multi-triplet value, only the triplet with
* the given domain is returned.
*
* @param str Gtid string
* @param search_domain The Gtid domain whose triplet should be returned. Negative domain stands for
* autoselect, which is only allowed when the string contains one triplet.
*/
Gtid(const char* str, int64_t search_domain = -1)
: domain(0)
, server_id(SERVER_ID_UNKNOWN)
, sequence(0)
{
// Autoselect only allowed with one triplet
ss_dassert(search_domain >= 0 || strchr(str, ',') == NULL);
parse_triplet(str);
if (search_domain >= 0 && domain != search_domain)
{
// Search for the correct triplet.
bool found = false;
for (const char* next_triplet = strchr(str, ',');
next_triplet != NULL && !found;
next_triplet = strchr(next_triplet, ','))
{
parse_triplet(++next_triplet);
if (domain == search_domain)
{
found = true;
}
}
ss_dassert(found);
}
}
bool operator == (const Gtid& rhs) const
{
return domain == rhs.domain &&
server_id != SERVER_ID_UNKNOWN && server_id == rhs.server_id &&
sequence == rhs.sequence;
}
string to_string() const
{
std::stringstream ss;
if (server_id != SERVER_ID_UNKNOWN)
{
ss << domain << "-" << server_id << "-" << sequence;
}
return ss.str();
}
private:
void parse_triplet(const char* str)
{
ss_debug(int rv = ) sscanf(str, "%" PRIu32 "-%" PRId64 "-%" PRIu64, &domain, &server_id, &sequence);
ss_dassert(rv == 3);
}
};
// Contains data returned by one row of SHOW ALL SLAVES STATUS
class SlaveStatusInfo
{
public:
int64_t master_server_id; /**< The master's server_id value. Valid ids are 32bit unsigned. -1 is
* unread/error. */
string master_host; /**< Master server host name. */
int master_port; /**< Master server port. */
bool slave_io_running; /**< Whether the slave I/O thread is running and connected. */
bool slave_sql_running; /**< Whether or not the SQL thread is running. */
string master_log_file; /**< Name of the master binary log file that the I/O thread is currently
* reading from. */
uint64_t read_master_log_pos; /**< Position up to which the I/O thread has read in the current master
* binary log file. */
Gtid gtid_io_pos; /**< Gtid I/O position of the slave thread. Only shows the triplet with
* the current master domain. */
string last_error; /**< Last IO or SQL error encountered. */
SlaveStatusInfo()
: master_server_id(SERVER_ID_UNKNOWN)
, master_port(0)
, slave_io_running(false)
, slave_sql_running(false)
, read_master_log_pos(0)
{}
};
// This class groups some miscellaneous replication related settings together.
class ReplicationSettings
{
public:
bool gtid_strict_mode; /**< Enable additional checks for replication */
bool log_bin; /**< Is binary logging enabled */
bool log_slave_updates; /**< Does the slave log replicated events to binlog */
ReplicationSettings()
: gtid_strict_mode(false)
, log_bin(false)
, log_slave_updates(false)
{}
};
/**
* Monitor specific information about a server
*
* Note: These are initialized in @c init_server_info
*/
class MySqlServerInfo
{
public:
int64_t server_id; /**< Value of @@server_id. Valid values are 32bit unsigned. */
int group; /**< Multi-master group where this server belongs,
* 0 for servers not in groups */
bool read_only; /**< Value of @@read_only */
bool slave_configured; /**< Whether SHOW SLAVE STATUS returned rows */
bool binlog_relay; /** Server is a Binlog Relay */
int n_slaves_configured; /**< Number of configured slave connections*/
int n_slaves_running; /**< Number of running slave connections */
int slave_heartbeats; /**< Number of received heartbeats */
double heartbeat_period; /**< The time interval between heartbeats */
time_t latest_event; /**< Time when latest event was received from the master */
int64_t gtid_domain_id; /**< The value of gtid_domain_id, the domain which is used for
* new non-replicated events. */
Gtid gtid_current_pos; /**< Gtid of latest event. Only shows the triplet
* with the current master domain. */
Gtid gtid_binlog_pos; /**< Gtid of latest event written to binlog. Only shows
* the triplet with the current master domain. */
SlaveStatusInfo slave_status; /**< Data returned from SHOW SLAVE STATUS */
ReplicationSettings rpl_settings; /**< Miscellaneous replication related settings */
mysql_server_version version; /**< Server version, 10.X, 5.5 or 5.1 */
MySqlServerInfo()
: server_id(SERVER_ID_UNKNOWN)
, group(0)
, read_only(false)
, slave_configured(false)
, binlog_relay(false)
, n_slaves_configured(0)
, n_slaves_running(0)
, slave_heartbeats(0)
, heartbeat_period(0)
, latest_event(0)
, gtid_domain_id(-1)
, version(MYSQL_SERVER_VERSION_51)
{} {}
/** bool uses_gtid(MariaDBMonitor* mon, MXS_MONITORED_SERVER* mon_server, json_t** error_out)
* Calculate how many events are left in the relay log. If gtid_current_pos is ahead of Gtid_IO_Pos,
* or a server_id is unknown, an error value is returned.
*
* @return Number of events in relay log according to latest queried info. A negative value signifies
* an error in the gtid-values.
*/
int64_t relay_log_events()
{
if (slave_status.gtid_io_pos.server_id != SERVER_ID_UNKNOWN &&
gtid_current_pos.server_id != SERVER_ID_UNKNOWN &&
slave_status.gtid_io_pos.domain == gtid_current_pos.domain &&
slave_status.gtid_io_pos.sequence >= gtid_current_pos.sequence)
{
return slave_status.gtid_io_pos.sequence - gtid_current_pos.sequence;
}
return -1;
}
};
bool uses_gtid(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* mon_server, json_t** error_out)
{ {
bool rval = false; bool rval = false;
const MySqlServerInfo* info = get_server_info(mon, mon_server); const MySqlServerInfo* info = get_server_info(mon, mon_server);
@ -354,6 +182,7 @@ bool uses_gtid(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* mon_server, json_t** er
} }
return rval; return rval;
} }
/** /**
* Check that the given server is a master and it's the only master. * Check that the given server is a master and it's the only master.
* *
@ -364,7 +193,7 @@ bool uses_gtid(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* mon_server, json_t** er
* @return False, if there is some error with the specified current master, * @return False, if there is some error with the specified current master,
* True otherwise. * True otherwise.
*/ */
bool mysql_switchover_check_current(const MYSQL_MONITOR* mon, bool mysql_switchover_check_current(const MariaDBMonitor* mon,
const MXS_MONITORED_SERVER* suggested_curr_master, const MXS_MONITORED_SERVER* suggested_curr_master,
json_t** error_out) json_t** error_out)
{ {
@ -436,7 +265,7 @@ bool mysql_switchover_check_new(const MXS_MONITORED_SERVER* monitored_server, js
* @param error_out JSON error out * @param error_out JSON error out
* @return True if failover may proceed * @return True if failover may proceed
*/ */
bool failover_check(MYSQL_MONITOR* mon, json_t** error_out) bool failover_check(MariaDBMonitor* mon, json_t** error_out)
{ {
// Check that there is no running master and that there is at least one running server in the cluster. // Check that there is no running master and that there is at least one running server in the cluster.
// Also, all slaves must be using gtid-replication. // Also, all slaves must be using gtid-replication.
@ -508,7 +337,7 @@ bool mysql_switchover(MXS_MONITOR* mon, MXS_MONITORED_SERVER* new_master, MXS_MO
} }
bool rval = false; bool rval = false;
MYSQL_MONITOR* handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor* handle = static_cast<MariaDBMonitor*>(mon->handle);
bool current_ok = mysql_switchover_check_current(handle, current_master, error_out); bool current_ok = mysql_switchover_check_current(handle, current_master, error_out);
bool new_ok = mysql_switchover_check_new(new_master, error_out); bool new_ok = mysql_switchover_check_new(new_master, error_out);
@ -599,7 +428,7 @@ bool mysql_handle_switchover(const MODULECMD_ARG* args, json_t** error_out)
else else
{ {
// Autoselect current master // Autoselect current master
MYSQL_MONITOR* handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor* handle = static_cast<MariaDBMonitor*>(mon->handle);
if (handle->master) if (handle->master)
{ {
mon_curr_master = handle->master; mon_curr_master = handle->master;
@ -650,7 +479,7 @@ bool mysql_failover(MXS_MONITOR* mon, json_t** output)
} }
bool rv = true; bool rv = true;
MYSQL_MONITOR *handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor *handle = static_cast<MariaDBMonitor*>(mon->handle);
rv = failover_check(handle, output); rv = failover_check(handle, output);
if (rv) if (rv)
{ {
@ -719,7 +548,7 @@ bool mysql_rejoin(MXS_MONITOR* mon, SERVER* rejoin_server, json_t** output)
} }
bool rval = false; bool rval = false;
MYSQL_MONITOR *handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor *handle = static_cast<MariaDBMonitor*>(mon->handle);
if (cluster_can_be_joined(handle)) if (cluster_can_be_joined(handle))
{ {
MXS_MONITORED_SERVER* mon_server = mon_get_monitored_server(mon, rejoin_server); MXS_MONITORED_SERVER* mon_server = mon_get_monitored_server(mon, rejoin_server);
@ -941,41 +770,34 @@ void info_free_func(void *val)
* @brief Helper function that initializes the server info hashtable * @brief Helper function that initializes the server info hashtable
* *
* @param handle MariaDB monitor handle * @param handle MariaDB monitor handle
* @param database List of monitored databases
* @return True on success, false if initialization failed. At the moment * @return True on success, false if initialization failed. At the moment
* initialization can only fail if memory allocation fails. * initialization can only fail if memory allocation fails.
*/ */
bool init_server_info(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *database) void init_server_info(MariaDBMonitor *handle)
{ {
bool rval = true; ServerInfoMap& infos = handle->server_info;
infos.clear();
MySqlServerInfo info; for (MXS_MONITORED_SERVER* server = handle->monitor->monitored_servers; server; server = server->next)
while (database)
{ {
/** Delete any existing structures and replace them with empty ones */ ServerInfoMap::value_type new_val(server, MySqlServerInfo());
hashtable_delete(handle->server_info, database->server->unique_name); infos.insert(new_val);
}
if (!hashtable_add(handle->server_info, database->server->unique_name, &info))
{
rval = false;
break;
} }
database = database->next; static MySqlServerInfo* get_server_info(MariaDBMonitor* handle, const MXS_MONITORED_SERVER* db)
}
return rval;
}
static MySqlServerInfo* get_server_info(const MYSQL_MONITOR* handle, const MXS_MONITORED_SERVER* db)
{ {
void* value = hashtable_fetch(handle->server_info, db->server->unique_name); ServerInfoMap::iterator iter = handle->server_info.find(db);
ss_dassert(value); ss_dassert(iter != handle->server_info.end());
return static_cast<MySqlServerInfo*>(value); return &iter->second;
} }
static bool set_replication_credentials(MYSQL_MONITOR *handle, const MXS_CONFIG_PARAMETER* params) static const MySqlServerInfo* get_server_info(const MariaDBMonitor* handle, const MXS_MONITORED_SERVER* db)
{
return get_server_info(const_cast<MariaDBMonitor*>(handle), db);
}
static bool set_replication_credentials(MariaDBMonitor *handle, const MXS_CONFIG_PARAMETER* params)
{ {
bool rval = false; bool rval = false;
const char* repl_user = config_get_string(params, CN_REPLICATION_USER); const char* repl_user = config_get_string(params, CN_REPLICATION_USER);
@ -1007,9 +829,10 @@ static bool set_replication_credentials(MYSQL_MONITOR *handle, const MXS_CONFIG_
* @param server Server to test * @param server Server to test
* @return True if server is in the excluded-list of the monitor. * @return True if server is in the excluded-list of the monitor.
*/ */
static bool server_is_excluded(const MYSQL_MONITOR *handle, const MXS_MONITORED_SERVER* server) static bool server_is_excluded(const MariaDBMonitor *handle, const MXS_MONITORED_SERVER* server)
{ {
for (int i = 0; i < handle->n_excluded; i++) size_t n_excluded = handle->excluded_servers.size();
for (size_t i = 0; i < n_excluded; i++)
{ {
if (handle->excluded_servers[i] == server) if (handle->excluded_servers[i] == server)
{ {
@ -1032,33 +855,18 @@ static void *
startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params) startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params)
{ {
bool error = false; bool error = false;
MYSQL_MONITOR *handle = (MYSQL_MONITOR*) monitor->handle; MariaDBMonitor *handle = (MariaDBMonitor*) monitor->handle;
if (handle) if (handle)
{ {
handle->shutdown = 0; handle->shutdown = 0;
handle->script.clear(); handle->script.clear();
handle->replication_user.clear(); handle->replication_user.clear();
handle->replication_password.clear(); handle->replication_password.clear();
MXS_FREE(handle->excluded_servers); handle->excluded_servers.clear();
handle->excluded_servers = NULL;
handle->n_excluded = 0;
} }
else else
{ {
handle = new MYSQL_MONITOR; handle = new MariaDBMonitor;
HASHTABLE *server_info = hashtable_alloc(MAX_NUM_SLAVES,
hashtable_item_strhash, hashtable_item_strcmp);
if (server_info == NULL)
{
delete handle;
hashtable_free(server_info);
return NULL;
}
hashtable_memory_fns(server_info, hashtable_item_strdup, info_copy_func,
hashtable_item_free, info_free_func);
handle->server_info = server_info;
handle->shutdown = 0; handle->shutdown = 0;
handle->id = config_get_global_options()->id; handle->id = config_get_global_options()->id;
handle->warn_set_standalone_master = true; handle->warn_set_standalone_master = true;
@ -1087,13 +895,14 @@ startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params)
handle->auto_rejoin = config_get_bool(params, CN_AUTO_REJOIN); handle->auto_rejoin = config_get_bool(params, CN_AUTO_REJOIN);
handle->verify_master_failure = config_get_bool(params, CN_VERIFY_MASTER_FAILURE); handle->verify_master_failure = config_get_bool(params, CN_VERIFY_MASTER_FAILURE);
handle->master_failure_timeout = config_get_integer(params, CN_MASTER_FAILURE_TIMEOUT); handle->master_failure_timeout = config_get_integer(params, CN_MASTER_FAILURE_TIMEOUT);
handle->excluded_servers = NULL;
handle->n_excluded = mon_config_get_servers(params, CN_NO_PROMOTE_SERVERS, monitor, MXS_MONITORED_SERVER** excluded_array = NULL;
&handle->excluded_servers); int n_excluded = mon_config_get_servers(params, CN_NO_PROMOTE_SERVERS, monitor, &excluded_array);
if (handle->n_excluded < 0) for (int i = 0; i < n_excluded; i++)
{ {
error = true; handle->excluded_servers.push_back(excluded_array[i]);
} }
MXS_FREE(excluded_array);
if (!set_replication_credentials(handle, params)) if (!set_replication_credentials(handle, params))
{ {
@ -1107,15 +916,10 @@ startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params)
error = true; error = true;
} }
if (!init_server_info(handle, monitor->monitored_servers)) init_server_info(handle);
{
error = true;
}
if (error) if (error)
{ {
hashtable_free(handle->server_info);
MXS_FREE(handle->excluded_servers);
delete handle; delete handle;
handle = NULL; handle = NULL;
} }
@ -1126,7 +930,6 @@ startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params)
if (thread_start(&handle->thread, monitorMain, handle, 0) == NULL) if (thread_start(&handle->thread, monitorMain, handle, 0) == NULL)
{ {
MXS_ERROR("Failed to start monitor thread for monitor '%s'.", monitor->name); MXS_ERROR("Failed to start monitor thread for monitor '%s'.", monitor->name);
hashtable_free(handle->server_info);
delete handle; delete handle;
handle = NULL; handle = NULL;
} }
@ -1143,7 +946,7 @@ startMonitor(MXS_MONITOR *monitor, const MXS_CONFIG_PARAMETER* params)
static void static void
stopMonitor(MXS_MONITOR *mon) stopMonitor(MXS_MONITOR *mon)
{ {
MYSQL_MONITOR *handle = (MYSQL_MONITOR *) mon->handle; MariaDBMonitor *handle = (MariaDBMonitor *) mon->handle;
handle->shutdown = 1; handle->shutdown = 1;
thread_wait(handle->thread); thread_wait(handle->thread);
@ -1164,7 +967,7 @@ static bool stop_monitor(MXS_MONITOR* mon)
bool actually_stopped = false; bool actually_stopped = false;
MYSQL_MONITOR *handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor *handle = static_cast<MariaDBMonitor*>(mon->handle);
if (handle->status == MXS_MONITOR_RUNNING) if (handle->status == MXS_MONITOR_RUNNING)
{ {
@ -1175,9 +978,10 @@ static bool stop_monitor(MXS_MONITOR* mon)
return actually_stopped; return actually_stopped;
} }
static string monitored_servers_to_string(MXS_MONITORED_SERVER** array, size_t array_size) static string monitored_servers_to_string(const ServerVector& array)
{ {
string rval; string rval;
size_t array_size = array.size();
if (array_size > 0) if (array_size > 0)
{ {
const char* separator = ""; const char* separator = "";
@ -1198,7 +1002,7 @@ static string monitored_servers_to_string(MXS_MONITORED_SERVER** array, size_t a
*/ */
static void diagnostics(DCB *dcb, const MXS_MONITOR *mon) static void diagnostics(DCB *dcb, const MXS_MONITOR *mon)
{ {
const MYSQL_MONITOR *handle = (const MYSQL_MONITOR *)mon->handle; const MariaDBMonitor *handle = (const MariaDBMonitor *)mon->handle;
dcb_printf(dcb, "Automatic failover: %s\n", handle->auto_failover ? "Enabled" : "Disabled"); dcb_printf(dcb, "Automatic failover: %s\n", handle->auto_failover ? "Enabled" : "Disabled");
dcb_printf(dcb, "Failcount: %d\n", handle->failcount); dcb_printf(dcb, "Failcount: %d\n", handle->failcount);
@ -1209,17 +1013,16 @@ static void diagnostics(DCB *dcb, const MXS_MONITOR *mon)
dcb_printf(dcb, "Detect replication lag: %s\n", (handle->replicationHeartbeat) ? "Enabled" : "Disabled"); dcb_printf(dcb, "Detect replication lag: %s\n", (handle->replicationHeartbeat) ? "Enabled" : "Disabled");
dcb_printf(dcb, "Detect stale master: %s\n", (handle->detectStaleMaster == 1) ? dcb_printf(dcb, "Detect stale master: %s\n", (handle->detectStaleMaster == 1) ?
"Enabled" : "Disabled"); "Enabled" : "Disabled");
if (handle->n_excluded > 0) if (handle->excluded_servers.size() > 0)
{ {
dcb_printf(dcb, "Non-promotable servers (failover): "); dcb_printf(dcb, "Non-promotable servers (failover): ");
dcb_printf(dcb, "%s\n", dcb_printf(dcb, "%s\n", monitored_servers_to_string(handle->excluded_servers).c_str());
monitored_servers_to_string(handle->excluded_servers, handle->n_excluded).c_str());
} }
dcb_printf(dcb, "\nServer information:\n-------------------\n\n"); dcb_printf(dcb, "\nServer information:\n-------------------\n\n");
for (MXS_MONITORED_SERVER *db = mon->monitored_servers; db; db = db->next) for (MXS_MONITORED_SERVER *db = mon->monitored_servers; db; db = db->next)
{ {
MySqlServerInfo *serv_info = get_server_info(handle, db); const MySqlServerInfo* serv_info = get_server_info(handle, db);
dcb_printf(dcb, "Server: %s\n", db->server->unique_name); dcb_printf(dcb, "Server: %s\n", db->server->unique_name);
dcb_printf(dcb, "Server ID: %" PRId64 "\n", serv_info->server_id); dcb_printf(dcb, "Server ID: %" PRId64 "\n", serv_info->server_id);
dcb_printf(dcb, "Read only: %s\n", serv_info->read_only ? "YES" : "NO"); dcb_printf(dcb, "Read only: %s\n", serv_info->read_only ? "YES" : "NO");
@ -1265,7 +1068,7 @@ static json_t* diagnostics_json(const MXS_MONITOR *mon)
{ {
json_t* rval = json_object(); json_t* rval = json_object();
const MYSQL_MONITOR *handle = (const MYSQL_MONITOR *)mon->handle; const MariaDBMonitor *handle = (const MariaDBMonitor *)mon->handle;
json_object_set_new(rval, "monitor_id", json_integer(handle->id)); json_object_set_new(rval, "monitor_id", json_integer(handle->id));
json_object_set_new(rval, "detect_stale_master", json_boolean(handle->detectStaleMaster)); json_object_set_new(rval, "detect_stale_master", json_boolean(handle->detectStaleMaster));
json_object_set_new(rval, "detect_stale_slave", json_boolean(handle->detectStaleSlave)); json_object_set_new(rval, "detect_stale_slave", json_boolean(handle->detectStaleSlave));
@ -1284,9 +1087,9 @@ static json_t* diagnostics_json(const MXS_MONITOR *mon)
{ {
json_object_set_new(rval, "script", json_string(handle->script.c_str())); json_object_set_new(rval, "script", json_string(handle->script.c_str()));
} }
if (handle->n_excluded > 0) if (handle->excluded_servers.size() > 0)
{ {
string list = monitored_servers_to_string(handle->excluded_servers, handle->n_excluded); string list = monitored_servers_to_string(handle->excluded_servers);
json_object_set_new(rval, CN_NO_PROMOTE_SERVERS, json_string(list.c_str())); json_object_set_new(rval, CN_NO_PROMOTE_SERVERS, json_string(list.c_str()));
} }
if (mon->monitored_servers) if (mon->monitored_servers)
@ -1296,7 +1099,7 @@ static json_t* diagnostics_json(const MXS_MONITOR *mon)
for (MXS_MONITORED_SERVER *db = mon->monitored_servers; db; db = db->next) for (MXS_MONITORED_SERVER *db = mon->monitored_servers; db; db = db->next)
{ {
json_t* srv = json_object(); json_t* srv = json_object();
MySqlServerInfo *serv_info = get_server_info(handle, db); const MySqlServerInfo* serv_info = get_server_info(handle, db);
json_object_set_new(srv, "name", json_string(db->server->unique_name)); json_object_set_new(srv, "name", json_string(db->server->unique_name));
json_object_set_new(srv, "server_id", json_integer(serv_info->server_id)); json_object_set_new(srv, "server_id", json_integer(serv_info->server_id));
json_object_set_new(srv, "master_id", json_integer(serv_info->slave_status.master_server_id)); json_object_set_new(srv, "master_id", json_integer(serv_info->slave_status.master_server_id));
@ -1348,7 +1151,7 @@ static enum mysql_server_version get_server_version(MXS_MONITORED_SERVER* db)
return MYSQL_SERVER_VERSION_51; return MYSQL_SERVER_VERSION_51;
} }
static bool do_show_slave_status(MYSQL_MONITOR* mon, static bool do_show_slave_status(MariaDBMonitor* mon,
MySqlServerInfo* serv_info, MySqlServerInfo* serv_info,
MXS_MONITORED_SERVER* database) MXS_MONITORED_SERVER* database)
{ {
@ -1510,7 +1313,7 @@ static bool do_show_slave_status(MYSQL_MONITOR* mon,
* @param handle Cluster monitor * @param handle Cluster monitor
* @return True, if a slave has an event more recent than master_failure_timeout. * @return True, if a slave has an event more recent than master_failure_timeout.
*/ */
static bool slave_receiving_events(MYSQL_MONITOR* handle) static bool slave_receiving_events(MariaDBMonitor* handle)
{ {
ss_dassert(handle->master); ss_dassert(handle->master);
bool received_event = false; bool received_event = false;
@ -1534,7 +1337,7 @@ static bool slave_receiving_events(MYSQL_MONITOR* handle)
return received_event; return received_event;
} }
static inline void monitor_mysql_db(MYSQL_MONITOR* mon, static inline void monitor_mysql_db(MariaDBMonitor* mon,
MXS_MONITORED_SERVER* database, MXS_MONITORED_SERVER* database,
MySqlServerInfo *serv_info) MySqlServerInfo *serv_info)
{ {
@ -1569,7 +1372,7 @@ static MXS_MONITORED_SERVER *build_mysql51_replication_tree(MXS_MONITOR *mon)
MXS_MONITORED_SERVER* database = mon->monitored_servers; MXS_MONITORED_SERVER* database = mon->monitored_servers;
MXS_MONITORED_SERVER *ptr, *rval = NULL; MXS_MONITORED_SERVER *ptr, *rval = NULL;
int i; int i;
MYSQL_MONITOR *handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor *handle = static_cast<MariaDBMonitor*>(mon->handle);
while (database) while (database)
{ {
@ -1675,7 +1478,7 @@ static MXS_MONITORED_SERVER *build_mysql51_replication_tree(MXS_MONITOR *mon)
static void static void
monitorDatabase(MXS_MONITOR *mon, MXS_MONITORED_SERVER *database) monitorDatabase(MXS_MONITOR *mon, MXS_MONITORED_SERVER *database)
{ {
MYSQL_MONITOR* handle = static_cast<MYSQL_MONITOR*>(mon->handle); MariaDBMonitor* handle = static_cast<MariaDBMonitor*>(mon->handle);
/* Don't probe servers in maintenance mode */ /* Don't probe servers in maintenance mode */
if (SERVER_IN_MAINT(database->server)) if (SERVER_IN_MAINT(database->server))
@ -1903,7 +1706,7 @@ static void visit_node(struct graph_node *node, struct graph_node **stack,
* member. Nodes in a group get a positive group ID where the nodes not in a * member. Nodes in a group get a positive group ID where the nodes not in a
* group get a group ID of 0. * group get a group ID of 0.
*/ */
void find_graph_cycles(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *database, int nservers) void find_graph_cycles(MariaDBMonitor *handle, MXS_MONITORED_SERVER *database, int nservers)
{ {
struct graph_node graph[nservers]; struct graph_node graph[nservers];
struct graph_node *stack[nservers]; struct graph_node *stack[nservers];
@ -2009,7 +1812,7 @@ void find_graph_cycles(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *database, in
* *
* @return True if standalone master should be used * @return True if standalone master should be used
*/ */
bool standalone_master_required(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *db) bool standalone_master_required(MariaDBMonitor *handle, MXS_MONITORED_SERVER *db)
{ {
int candidates = 0; int candidates = 0;
@ -2046,7 +1849,7 @@ bool standalone_master_required(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *db)
* @param handle Monitor instance * @param handle Monitor instance
* @param db Monitor servers * @param db Monitor servers
*/ */
bool set_standalone_master(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *db) bool set_standalone_master(MariaDBMonitor *handle, MXS_MONITORED_SERVER *db)
{ {
bool rval = false; bool rval = false;
@ -2080,7 +1883,7 @@ bool set_standalone_master(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *db)
return rval; return rval;
} }
bool failover_not_possible(MYSQL_MONITOR* handle) bool failover_not_possible(MariaDBMonitor* handle)
{ {
bool rval = false; bool rval = false;
@ -2107,7 +1910,7 @@ bool failover_not_possible(MYSQL_MONITOR* handle)
static void static void
monitorMain(void *arg) monitorMain(void *arg)
{ {
MYSQL_MONITOR *handle = (MYSQL_MONITOR *) arg; MariaDBMonitor *handle = (MariaDBMonitor *) arg;
MXS_MONITOR* mon = handle->monitor; MXS_MONITOR* mon = handle->monitor;
MXS_MONITORED_SERVER *ptr; MXS_MONITORED_SERVER *ptr;
bool replication_heartbeat; bool replication_heartbeat;
@ -2677,7 +2480,7 @@ static int get_row_count(MXS_MONITORED_SERVER *database, const char* query)
* @param handle The monitor handle * @param handle The monitor handle
* @param database The number database server * @param database The number database server
*/ */
static void set_master_heartbeat(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *database) static void set_master_heartbeat(MariaDBMonitor *handle, MXS_MONITORED_SERVER *database)
{ {
unsigned long id = handle->id; unsigned long id = handle->id;
time_t heartbeat; time_t heartbeat;
@ -2798,7 +2601,7 @@ static void set_master_heartbeat(MYSQL_MONITOR *handle, MXS_MONITORED_SERVER *da
*/ */
static void set_slave_heartbeat(MXS_MONITOR* mon, MXS_MONITORED_SERVER *database) static void set_slave_heartbeat(MXS_MONITOR* mon, MXS_MONITORED_SERVER *database)
{ {
MYSQL_MONITOR *handle = (MYSQL_MONITOR*) mon->handle; MariaDBMonitor *handle = (MariaDBMonitor*) mon->handle;
unsigned long id = handle->id; unsigned long id = handle->id;
time_t heartbeat; time_t heartbeat;
char select_heartbeat_query[256] = ""; char select_heartbeat_query[256] = "";
@ -2908,7 +2711,7 @@ static void set_slave_heartbeat(MXS_MONITOR* mon, MXS_MONITORED_SERVER *database
static MXS_MONITORED_SERVER *get_replication_tree(MXS_MONITOR *mon, int num_servers) static MXS_MONITORED_SERVER *get_replication_tree(MXS_MONITOR *mon, int num_servers)
{ {
MYSQL_MONITOR* handle = (MYSQL_MONITOR*) mon->handle; MariaDBMonitor* handle = (MariaDBMonitor*) mon->handle;
MXS_MONITORED_SERVER *ptr; MXS_MONITORED_SERVER *ptr;
MXS_MONITORED_SERVER *backend; MXS_MONITORED_SERVER *backend;
SERVER *current; SERVER *current;
@ -3308,7 +3111,7 @@ void check_maxscale_schema_replication(MXS_MONITOR *monitor)
* @todo Currently this only works with flat replication topologies and * @todo Currently this only works with flat replication topologies and
* needs to be moved inside mysqlmon as it is MariaDB specific code. * needs to be moved inside mysqlmon as it is MariaDB specific code.
*/ */
bool mon_process_failover(MYSQL_MONITOR* monitor, uint32_t failover_timeout, bool* cluster_modified_out) bool mon_process_failover(MariaDBMonitor* monitor, uint32_t failover_timeout, bool* cluster_modified_out)
{ {
ss_dassert(*cluster_modified_out == false); ss_dassert(*cluster_modified_out == false);
bool rval = true; bool rval = true;
@ -3389,7 +3192,7 @@ bool mon_process_failover(MYSQL_MONITOR* monitor, uint32_t failover_timeout, boo
* @param server Slave to update * @param server Slave to update
* @return Slave server info. NULL on error, or if server is not a slave. * @return Slave server info. NULL on error, or if server is not a slave.
*/ */
static MySqlServerInfo* update_slave_info(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* server) static MySqlServerInfo* update_slave_info(MariaDBMonitor* mon, MXS_MONITORED_SERVER* server)
{ {
MySqlServerInfo* info = get_server_info(mon, server); MySqlServerInfo* info = get_server_info(mon, server);
if (info->slave_status.slave_sql_running && if (info->slave_status.slave_sql_running &&
@ -3453,7 +3256,7 @@ static bool check_replication_settings(const MXS_MONITORED_SERVER* server, MySql
* @param err_out Json object for error printing. Can be NULL. * @param err_out Json object for error printing. Can be NULL.
* @return True, if given slave is a valid promotion candidate. * @return True, if given slave is a valid promotion candidate.
*/ */
bool switchover_check_preferred_master(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* preferred, json_t** err_out) bool switchover_check_preferred_master(MariaDBMonitor* mon, MXS_MONITORED_SERVER* preferred, json_t** err_out)
{ {
ss_dassert(preferred); ss_dassert(preferred);
bool rval = true; bool rval = true;
@ -3512,7 +3315,7 @@ bool is_candidate_better(const MySqlServerInfo* current_best_info, const MySqlSe
* @param err_out json object for error printing. Can be NULL. * @param err_out json object for error printing. Can be NULL.
* @return The found master, or NULL if not found * @return The found master, or NULL if not found
*/ */
MXS_MONITORED_SERVER* select_new_master(MYSQL_MONITOR* mon, ServerVector* slaves_out, json_t** err_out) MXS_MONITORED_SERVER* select_new_master(MariaDBMonitor* mon, ServerVector* slaves_out, json_t** err_out)
{ {
ss_dassert(slaves_out && slaves_out->size() == 0); ss_dassert(slaves_out && slaves_out->size() == 0);
/* Select a new master candidate. Selects the one with the latest event in relay log. /* Select a new master candidate. Selects the one with the latest event in relay log.
@ -3605,7 +3408,7 @@ MXS_MONITORED_SERVER* select_new_master(MYSQL_MONITOR* mon, ServerVector* slaves
* @param err_out Json error output * @param err_out Json error output
* @return True if relay log was processed within time limit, or false if time ran out or an error occurred. * @return True if relay log was processed within time limit, or false if time ran out or an error occurred.
*/ */
bool failover_wait_relay_log(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, int seconds_remaining, bool failover_wait_relay_log(MariaDBMonitor* mon, MXS_MONITORED_SERVER* new_master, int seconds_remaining,
json_t** err_out) json_t** err_out)
{ {
MySqlServerInfo* master_info = get_server_info(mon, new_master); MySqlServerInfo* master_info = get_server_info(mon, new_master);
@ -3658,7 +3461,7 @@ bool failover_wait_relay_log(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_maste
return rval; return rval;
} }
bool start_external_replication(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, json_t** err_out) bool start_external_replication(MariaDBMonitor* mon, MXS_MONITORED_SERVER* new_master, json_t** err_out)
{ {
bool rval = false; bool rval = false;
string change_cmd = generate_change_master_cmd(mon, mon->external_master_host, mon->external_master_port); string change_cmd = generate_change_master_cmd(mon, mon->external_master_host, mon->external_master_port);
@ -3685,7 +3488,7 @@ bool start_external_replication(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_ma
* @param err_out json object for error printing. Can be NULL. * @param err_out json object for error printing. Can be NULL.
* @return True if successful * @return True if successful
*/ */
bool promote_new_master(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, json_t** err_out) bool promote_new_master(MariaDBMonitor* mon, MXS_MONITORED_SERVER* new_master, json_t** err_out)
{ {
bool success = false; bool success = false;
MXS_NOTICE("Promoting server '%s' to master.", new_master->server->unique_name); MXS_NOTICE("Promoting server '%s' to master.", new_master->server->unique_name);
@ -3726,7 +3529,7 @@ bool promote_new_master(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, js
* @param master_port Master port * @param master_port Master port
* @return Generated query * @return Generated query
*/ */
string generate_change_master_cmd(MYSQL_MONITOR* mon, const string& master_host, int master_port) string generate_change_master_cmd(MariaDBMonitor* mon, const string& master_host, int master_port)
{ {
std::stringstream change_cmd; std::stringstream change_cmd;
change_cmd << "CHANGE MASTER TO MASTER_HOST = '" << master_host << "', "; change_cmd << "CHANGE MASTER TO MASTER_HOST = '" << master_host << "', ";
@ -3780,7 +3583,7 @@ bool redirect_one_slave(MXS_MONITORED_SERVER* slave, const char* change_cmd)
* @param redirected_slaves A vector where to insert successfully redirected slaves. Can be NULL. * @param redirected_slaves A vector where to insert successfully redirected slaves. Can be NULL.
* @return The number of slaves successfully redirected. * @return The number of slaves successfully redirected.
*/ */
int redirect_slaves(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* new_master, const ServerVector& slaves, int redirect_slaves(MariaDBMonitor* mon, MXS_MONITORED_SERVER* new_master, const ServerVector& slaves,
ServerVector* redirected_slaves = NULL) ServerVector* redirected_slaves = NULL)
{ {
MXS_NOTICE("Redirecting slaves to new master."); MXS_NOTICE("Redirecting slaves to new master.");
@ -3838,7 +3641,7 @@ void print_redirect_errors(MXS_MONITORED_SERVER* first_server, const ServerVecto
* @param err_out Json output * @param err_out Json output
* @return True if successful * @return True if successful
*/ */
static bool do_failover(MYSQL_MONITOR* mon, json_t** err_out) static bool do_failover(MariaDBMonitor* mon, json_t** err_out)
{ {
// Topology has already been tested to be simple. // Topology has already been tested to be simple.
if (mon->master_gtid_domain < 0) if (mon->master_gtid_domain < 0)
@ -3993,7 +3796,7 @@ static bool update_replication_settings(MXS_MONITORED_SERVER *database, MySqlSer
* @param info Server info structure for saving result * @param info Server info structure for saving result
* @return True if successful * @return True if successful
*/ */
static bool update_gtids(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER *database, MySqlServerInfo* info) static bool update_gtids(MariaDBMonitor* mon, MXS_MONITORED_SERVER *database, MySqlServerInfo* info)
{ {
StringVector row; StringVector row;
const char query[] = "SELECT @@gtid_current_pos, @@gtid_binlog_pos;"; const char query[] = "SELECT @@gtid_current_pos, @@gtid_binlog_pos;";
@ -4023,7 +3826,7 @@ static bool update_gtids(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER *database, MyS
* @param err_out json object for error printing. Can be NULL. * @param err_out json object for error printing. Can be NULL.
* @return True if successful. * @return True if successful.
*/ */
static bool switchover_demote_master(MYSQL_MONITOR* mon, static bool switchover_demote_master(MariaDBMonitor* mon,
MXS_MONITORED_SERVER* current_master, MXS_MONITORED_SERVER* current_master,
MySqlServerInfo* info, MySqlServerInfo* info,
json_t** err_out) json_t** err_out)
@ -4226,7 +4029,7 @@ static bool switchover_wait_slaves_catchup(const ServerVector& slaves, const Gti
* @return True if commands were accepted. This does not guarantee that replication proceeds * @return True if commands were accepted. This does not guarantee that replication proceeds
* successfully. * successfully.
*/ */
static bool switchover_start_slave(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* old_master, SERVER* new_master) static bool switchover_start_slave(MariaDBMonitor* mon, MXS_MONITORED_SERVER* old_master, SERVER* new_master)
{ {
bool rval = false; bool rval = false;
std::string change_cmd = generate_change_master_cmd(mon, new_master->name, new_master->port); std::string change_cmd = generate_change_master_cmd(mon, new_master->name, new_master->port);
@ -4277,7 +4080,7 @@ static string get_connection_errors(const ServerVector& servers)
* @param seconds_remaining How long can we wait * @param seconds_remaining How long can we wait
* @return True, if at least one slave got the new event within the time limit * @return True, if at least one slave got the new event within the time limit
*/ */
static bool wait_cluster_stabilization(MYSQL_MONITOR* mon, static bool wait_cluster_stabilization(MariaDBMonitor* mon,
MXS_MONITORED_SERVER* new_master, MXS_MONITORED_SERVER* new_master,
const ServerVector& slaves, const ServerVector& slaves,
int seconds_remaining) int seconds_remaining)
@ -4371,7 +4174,7 @@ static bool wait_cluster_stabilization(MYSQL_MONITOR* mon,
* @return True if successful. If false, the cluster can be in various situations depending on which step * @return True if successful. If false, the cluster can be in various situations depending on which step
* failed. In practice, manual intervention is usually required on failure. * failed. In practice, manual intervention is usually required on failure.
*/ */
static bool do_switchover(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* current_master, static bool do_switchover(MariaDBMonitor* mon, MXS_MONITORED_SERVER* current_master,
MXS_MONITORED_SERVER* new_master, json_t** err_out) MXS_MONITORED_SERVER* new_master, json_t** err_out)
{ {
MXS_MONITORED_SERVER* demotion_target = current_master ? current_master : mon->master; MXS_MONITORED_SERVER* demotion_target = current_master ? current_master : mon->master;
@ -4568,7 +4371,7 @@ static void read_server_variables(MXS_MONITORED_SERVER* database, MySqlServerInf
* @param master_info Master info * @param master_info Master info
* @return True if slave can replicate from master * @return True if slave can replicate from master
*/ */
static bool can_replicate_from(MYSQL_MONITOR* mon, static bool can_replicate_from(MariaDBMonitor* mon,
MXS_MONITORED_SERVER* slave, MySqlServerInfo* slave_info, MXS_MONITORED_SERVER* slave, MySqlServerInfo* slave_info,
MXS_MONITORED_SERVER* master, MySqlServerInfo* master_info) MXS_MONITORED_SERVER* master, MySqlServerInfo* master_info)
{ {
@ -4599,7 +4402,7 @@ static bool can_replicate_from(MYSQL_MONITOR* mon,
* @param master_info Master server info * @param master_info Master server info
* @return True, if server is a rejoin suspect. * @return True, if server is a rejoin suspect.
*/ */
static bool server_is_rejoin_suspect(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* server, static bool server_is_rejoin_suspect(MariaDBMonitor* mon, MXS_MONITORED_SERVER* server,
MySqlServerInfo* master_info) MySqlServerInfo* master_info)
{ {
bool is_suspect = false; bool is_suspect = false;
@ -4643,7 +4446,7 @@ static bool server_is_rejoin_suspect(MYSQL_MONITOR* mon, MXS_MONITORED_SERVER* s
* @return False, if there were possible rejoinable servers but communications error to master server * @return False, if there were possible rejoinable servers but communications error to master server
* prevented final checks. * prevented final checks.
*/ */
static bool get_joinable_servers(MYSQL_MONITOR* mon, ServerVector* output) static bool get_joinable_servers(MariaDBMonitor* mon, ServerVector* output)
{ {
ss_dassert(output); ss_dassert(output);
MXS_MONITORED_SERVER* master = mon->master; MXS_MONITORED_SERVER* master = mon->master;
@ -4694,7 +4497,7 @@ static bool get_joinable_servers(MYSQL_MONITOR* mon, ServerVector* output)
* @param joinable_servers Which servers to rejoin * @param joinable_servers Which servers to rejoin
* @return The number of servers successfully rejoined * @return The number of servers successfully rejoined
*/ */
static uint32_t do_rejoin(MYSQL_MONITOR* mon, const ServerVector& joinable_servers) static uint32_t do_rejoin(MariaDBMonitor* mon, const ServerVector& joinable_servers)
{ {
SERVER* master = mon->master->server; SERVER* master = mon->master->server;
uint32_t servers_joined = 0; uint32_t servers_joined = 0;
@ -4764,7 +4567,7 @@ static bool join_cluster(MXS_MONITORED_SERVER* server, const char* change_cmd)
* @param mon Cluster monitor * @param mon Cluster monitor
* @param setting_name Setting to disable * @param setting_name Setting to disable
*/ */
static void disable_setting(MYSQL_MONITOR* mon, const char* setting) static void disable_setting(MariaDBMonitor* mon, const char* setting)
{ {
MXS_CONFIG_PARAMETER p = {}; MXS_CONFIG_PARAMETER p = {};
p.name = const_cast<char*>(setting); p.name = const_cast<char*>(setting);
@ -4778,7 +4581,7 @@ static void disable_setting(MYSQL_MONITOR* mon, const char* setting)
* @param mon Cluster monitor * @param mon Cluster monitor
* @return True, if cluster can be joined * @return True, if cluster can be joined
*/ */
static bool cluster_can_be_joined(MYSQL_MONITOR* mon) static bool cluster_can_be_joined(MariaDBMonitor* mon)
{ {
return (mon->master != NULL && SERVER_IS_MASTER(mon->master->server) && mon->master_gtid_domain >= 0); return (mon->master != NULL && SERVER_IS_MASTER(mon->master->server) && mon->master_gtid_domain >= 0);
} }

26
server/modules/monitor/mariadbmon/mariadbmon.hh
View File

@ -15,25 +15,36 @@
#include <maxscale/cppdefs.hh> #include <maxscale/cppdefs.hh>
#include <string> #include <string>
#include <tr1/unordered_map>
#include <vector>
#include <maxscale/config.h>
#include <maxscale/dcb.h>
#include <maxscale/hashtable.h>
#include <maxscale/monitor.h> #include <maxscale/monitor.h>
#include <maxscale/thread.h> #include <maxscale/thread.h>
using std::string; #include "utilities.hh"
extern const int PORT_UNKNOWN;
extern const int64_t SERVER_ID_UNKNOWN;
typedef std::tr1::unordered_map<const MXS_MONITORED_SERVER*, MySqlServerInfo> ServerInfoMap;
typedef std::vector<MXS_MONITORED_SERVER*> ServerVector;
// MariaDB Monitor instance data // MariaDB Monitor instance data
class MYSQL_MONITOR class MariaDBMonitor
{ {
private:
MariaDBMonitor(const MariaDBMonitor&);
MariaDBMonitor& operator = (const MariaDBMonitor&);
public: public:
MariaDBMonitor();
~MariaDBMonitor();
MXS_MONITOR* monitor; /**< Generic monitor object */ MXS_MONITOR* monitor; /**< Generic monitor object */
THREAD thread; /**< Monitor thread */ THREAD thread; /**< Monitor thread */
int shutdown; /**< Flag to shutdown the monitor thread */ int shutdown; /**< Flag to shutdown the monitor thread */
int status; /**< Monitor status */ int status; /**< Monitor status */
MXS_MONITORED_SERVER *master; /**< Master server for MySQL Master/Slave replication */ MXS_MONITORED_SERVER *master; /**< Master server for MySQL Master/Slave replication */
HASHTABLE *server_info; /**< Contains server specific information */ ServerInfoMap server_info; /**< Contains server specific information */
bool warn_set_standalone_master; /**< Log a warning when setting standalone master */ bool warn_set_standalone_master; /**< Log a warning when setting standalone master */
unsigned long id; /**< Monitor ID */ unsigned long id; /**< Monitor ID */
@ -63,8 +74,7 @@ public:
bool auto_failover; /**< If automatic master failover is enabled */ bool auto_failover; /**< If automatic master failover is enabled */
bool auto_rejoin; /**< Attempt to start slave replication on standalone servers or servers bool auto_rejoin; /**< Attempt to start slave replication on standalone servers or servers
* replicating from the wrong master automatically. */ * replicating from the wrong master automatically. */
MXS_MONITORED_SERVER** excluded_servers; /**< Servers banned for master promotion during auto-failover. */ ServerVector excluded_servers; /**< Servers banned for master promotion during auto-failover. */
int n_excluded; /**< Number of excluded servers */
// Other settings // Other settings
string script; /**< Script to call when state changes occur on servers */ string script; /**< Script to call when state changes occur on servers */

112
server/modules/monitor/mariadbmon/utilities.cc Normal file
View File

@ -0,0 +1,112 @@
/*
* Copyright (c) 2018 MariaDB Corporation Ab
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
*
* Change Date: 2020-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2 or later of the General
* Public License.
*/
#include "utilities.hh"
#include <inttypes.h>
#include <stdio.h>
#include <string>
#include <sstream>
#include <maxscale/debug.h>
#include "mariadbmon.hh"
Gtid::Gtid()
: domain(0)
, server_id(SERVER_ID_UNKNOWN)
, sequence(0)
{}
Gtid::Gtid(const char* str, int64_t search_domain)
: domain(0)
, server_id(SERVER_ID_UNKNOWN)
, sequence(0)
{
// Autoselect only allowed with one triplet
ss_dassert(search_domain >= 0 || strchr(str, ',') == NULL);
parse_triplet(str);
if (search_domain >= 0 && domain != search_domain)
{
// Search for the correct triplet.
bool found = false;
for (const char* next_triplet = strchr(str, ',');
next_triplet != NULL && !found;
next_triplet = strchr(next_triplet, ','))
{
parse_triplet(++next_triplet);
if (domain == search_domain)
{
found = true;
}
}
ss_dassert(found);
}
}
bool Gtid::operator == (const Gtid& rhs) const
{
return domain == rhs.domain &&
server_id != SERVER_ID_UNKNOWN && server_id == rhs.server_id &&
sequence == rhs.sequence;
}
string Gtid::to_string() const
{
std::stringstream ss;
if (server_id != SERVER_ID_UNKNOWN)
{
ss << domain << "-" << server_id << "-" << sequence;
}
return ss.str();
}
void Gtid::parse_triplet(const char* str)
{
ss_debug(int rv = ) sscanf(str, "%" PRIu32 "-%" PRId64 "-%" PRIu64, &domain, &server_id, &sequence);
ss_dassert(rv == 3);
}
SlaveStatusInfo::SlaveStatusInfo()
: master_server_id(SERVER_ID_UNKNOWN)
, master_port(0)
, slave_io_running(false)
, slave_sql_running(false)
, read_master_log_pos(0)
{}
MySqlServerInfo::MySqlServerInfo()
: server_id(SERVER_ID_UNKNOWN)
, group(0)
, read_only(false)
, slave_configured(false)
, binlog_relay(false)
, n_slaves_configured(0)
, n_slaves_running(0)
, slave_heartbeats(0)
, heartbeat_period(0)
, latest_event(0)
, gtid_domain_id(-1)
, version(MYSQL_SERVER_VERSION_51)
{}
int64_t MySqlServerInfo::relay_log_events()
{
if (slave_status.gtid_io_pos.server_id != SERVER_ID_UNKNOWN &&
gtid_current_pos.server_id != SERVER_ID_UNKNOWN &&
slave_status.gtid_io_pos.domain == gtid_current_pos.domain &&
slave_status.gtid_io_pos.sequence >= gtid_current_pos.sequence)
{
return slave_status.gtid_io_pos.sequence - gtid_current_pos.sequence;
}
return -1;
}

127
server/modules/monitor/mariadbmon/utilities.hh Normal file
View File

@ -0,0 +1,127 @@
#pragma once
/*
* Copyright (c) 2018 MariaDB Corporation Ab
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
*
* Change Date: 2020-01-01
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2 or later of the General
* Public License.
*/
#include <maxscale/cppdefs.hh>
#include <string>
using std::string;
enum mysql_server_version
{
MYSQL_SERVER_VERSION_100,
MYSQL_SERVER_VERSION_55,
MYSQL_SERVER_VERSION_51
};
class Gtid
{
public:
uint32_t domain;
int64_t server_id; // Is actually 32bit unsigned. 0 is only used by server versions <= 10.1
uint64_t sequence;
Gtid();
/**
* Parse a Gtid-triplet from a string. In case of a multi-triplet value, only the triplet with
* the given domain is returned.
*
* @param str Gtid string
* @param search_domain The Gtid domain whose triplet should be returned. Negative domain stands for
* autoselect, which is only allowed when the string contains one triplet.
*/
Gtid(const char* str, int64_t search_domain = -1);
bool operator == (const Gtid& rhs) const;
string to_string() const;
private:
void parse_triplet(const char* str);
};
// Contains data returned by one row of SHOW ALL SLAVES STATUS
class SlaveStatusInfo
{
public:
int64_t master_server_id; /**< The master's server_id value. Valid ids are 32bit unsigned. -1 is
* unread/error. */
string master_host; /**< Master server host name. */
int master_port; /**< Master server port. */
bool slave_io_running; /**< Whether the slave I/O thread is running and connected. */
bool slave_sql_running; /**< Whether or not the SQL thread is running. */
string master_log_file; /**< Name of the master binary log file that the I/O thread is currently
* reading from. */
uint64_t read_master_log_pos; /**< Position up to which the I/O thread has read in the current master
* binary log file. */
Gtid gtid_io_pos; /**< Gtid I/O position of the slave thread. Only shows the triplet with
* the current master domain. */
string last_error; /**< Last IO or SQL error encountered. */
SlaveStatusInfo();
};
// This class groups some miscellaneous replication related settings together.
class ReplicationSettings
{
public:
bool gtid_strict_mode; /**< Enable additional checks for replication */
bool log_bin; /**< Is binary logging enabled */
bool log_slave_updates; /**< Does the slave log replicated events to binlog */
ReplicationSettings()
: gtid_strict_mode(false)
, log_bin(false)
, log_slave_updates(false)
{}
};
/**
* Monitor specific information about a server
*
* Note: These are initialized in @c init_server_info
*/
class MySqlServerInfo
{
public:
int64_t server_id; /**< Value of @@server_id. Valid values are 32bit unsigned. */
int group; /**< Multi-master group where this server belongs,
* 0 for servers not in groups */
bool read_only; /**< Value of @@read_only */
bool slave_configured; /**< Whether SHOW SLAVE STATUS returned rows */
bool binlog_relay; /** Server is a Binlog Relay */
int n_slaves_configured; /**< Number of configured slave connections*/
int n_slaves_running; /**< Number of running slave connections */
int slave_heartbeats; /**< Number of received heartbeats */
double heartbeat_period; /**< The time interval between heartbeats */
time_t latest_event; /**< Time when latest event was received from the master */
int64_t gtid_domain_id; /**< The value of gtid_domain_id, the domain which is used for
* new non-replicated events. */
Gtid gtid_current_pos; /**< Gtid of latest event. Only shows the triplet
* with the current master domain. */
Gtid gtid_binlog_pos; /**< Gtid of latest event written to binlog. Only shows
* the triplet with the current master domain. */
SlaveStatusInfo slave_status; /**< Data returned from SHOW SLAVE STATUS */
ReplicationSettings rpl_settings; /**< Miscellaneous replication related settings */
mysql_server_version version; /**< Server version, 10.X, 5.5 or 5.1 */
MySqlServerInfo();
/**
* Calculate how many events are left in the relay log. If gtid_current_pos is ahead of Gtid_IO_Pos,
* or a server_id is unknown, an error value is returned.
*
* @return Number of events in relay log according to latest queried info. A negative value signifies
* an error in the gtid-values.
*/
int64_t relay_log_events();
};