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

MXS-1703 Change type of m_master to MariaDBServer

Browse Source
This commit is contained in:
Esa Korhonen
2018-04-12 14:31:39 +03:00
parent e3b11d866f
commit 9fe57bfb9b
4 changed files with 58 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
server/modules/monitor/mariadbmon/cluster_discovery.cc
View File

@ -87,7 +87,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::build_mysql51_replication_tree()
/* Set the Slave Role */ /* Set the Slave Role */
if (ismaster) if (ismaster)
{ {
m_master = database; m_master = get_server_info(database);
MXS_DEBUG("Master server found at [%s]:%d with %d slaves", MXS_DEBUG("Master server found at [%s]:%d with %d slaves",
database->server->name, database->server->name,
@ -128,7 +128,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::build_mysql51_replication_tree()
} }
if (SERVER_IS_SLAVE(database->server) && if (SERVER_IS_SLAVE(database->server) &&
(database->server->master_id <= 0 || (database->server->master_id <= 0 ||
database->server->master_id != m_master->server->node_id)) database->server->master_id != m_master->server_base->server->node_id))
{ {
monitor_set_pending_status(database, SERVER_SLAVE); monitor_set_pending_status(database, SERVER_SLAVE);
@ -205,7 +205,7 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
if (current->depth > -1 && current->depth < root_level) if (current->depth > -1 && current->depth < root_level)
{ {
root_level = current->depth; root_level = current->depth;
m_master = ptr; m_master = get_server_info(ptr);
} }
backend = getServerByNodeId(node_id); backend = getServerByNodeId(node_id);
@ -236,12 +236,12 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
current->node_id); current->node_id);
master_cand->server->depth = current->depth - 1; master_cand->server->depth = current->depth - 1;
if (m_master && master_cand->server->depth < m_master->server->depth) if (m_master && master_cand->server->depth < m_master->server_base->server->depth)
{ {
/** A master with a lower depth was found, remove /** A master with a lower depth was found, remove
the master status from the previous master. */ the master status from the previous master. */
monitor_clear_pending_status(m_master, SERVER_MASTER); monitor_clear_pending_status(m_master->server_base, SERVER_MASTER);
m_master = master_cand; m_master = get_server_info(master_cand);
} }
MariaDBServer* info = get_server_info(master_cand); MariaDBServer* info = get_server_info(master_cand);
@ -275,13 +275,13 @@ MXS_MONITORED_SERVER* MariaDBMonitor::get_replication_tree()
if (m_master != NULL) if (m_master != NULL)
{ {
/* If the root master is in MAINT, return NULL */ /* If the root master is in MAINT, return NULL */
if (SERVER_IN_MAINT(m_master->server)) if (SERVER_IN_MAINT(m_master->server_base->server))
{ {
return NULL; return NULL;
} }
else else
{ {
return m_master; return m_master->server_base;
} }
} }
else else
@ -1017,7 +1017,7 @@ bool MariaDBMonitor::set_standalone_master(MXS_MONITORED_SERVER *db)
server_clear_set_status(db->server, SERVER_SLAVE, SERVER_MASTER | SERVER_STALE_STATUS); server_clear_set_status(db->server, SERVER_SLAVE, SERVER_MASTER | SERVER_STALE_STATUS);
monitor_set_pending_status(db, SERVER_MASTER | SERVER_STALE_STATUS); monitor_set_pending_status(db, SERVER_MASTER | SERVER_STALE_STATUS);
monitor_clear_pending_status(db, SERVER_SLAVE); monitor_clear_pending_status(db, SERVER_SLAVE);
m_master = db; m_master = get_server_info(db);
rval = true; rval = true;
} }
else if (!m_allow_cluster_recovery) else if (!m_allow_cluster_recovery)
@ -1110,7 +1110,7 @@ MariaDBServer* MariaDBMonitor::find_root_master()
monitor_set_pending_status(mon_server, SERVER_MASTER); monitor_set_pending_status(mon_server, SERVER_MASTER);
mon_server->server->depth = 0; mon_server->server->depth = 0;
m_master = mon_server; m_master = &m_servers[0];
found_root_master = mon_server; found_root_master = mon_server;
} }
} }

36
server/modules/monitor/mariadbmon/cluster_manipulation.cc
View File

@ -131,15 +131,14 @@ bool MariaDBMonitor::manual_rejoin(SERVER* rejoin_server, json_t** output)
MXS_MONITORED_SERVER* mon_slave_cand = mon_get_monitored_server(m_monitor_base, rejoin_server); MXS_MONITORED_SERVER* mon_slave_cand = mon_get_monitored_server(m_monitor_base, rejoin_server);
if (mon_slave_cand) if (mon_slave_cand)
{ {
const char* master_name = m_master->server->unique_name; const char* master_name = m_master->server_base->server->unique_name;
MariaDBServer* master = get_server_info(m_master);
MariaDBServer* slave_cand = get_server_info(mon_slave_cand); MariaDBServer* slave_cand = get_server_info(mon_slave_cand);
if (server_is_rejoin_suspect(slave_cand, master, output)) if (server_is_rejoin_suspect(slave_cand, m_master, output))
{ {
if (master->update_gtids()) if (m_master->update_gtids())
{ {
if (can_replicate_from(slave_cand, master)) if (can_replicate_from(slave_cand, m_master))
{ {
ServerRefArray joinable_server; ServerRefArray joinable_server;
joinable_server.push_back(slave_cand); joinable_server.push_back(slave_cand);
@ -338,7 +337,7 @@ bool MariaDBMonitor::redirect_one_slave(MXS_MONITORED_SERVER* slave, const char*
*/ */
uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers) uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
{ {
SERVER* master_server = m_master->server; SERVER* master_server = m_master->server_base->server;
const char* master_name = master_server->unique_name; const char* master_name = master_server->unique_name;
uint32_t servers_joined = 0; uint32_t servers_joined = 0;
if (!joinable_servers.empty()) if (!joinable_servers.empty())
@ -346,7 +345,7 @@ uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
string change_cmd = generate_change_master_cmd(master_server->name, master_server->port); string change_cmd = generate_change_master_cmd(master_server->name, master_server->port);
for (auto iter = joinable_servers.begin(); iter != joinable_servers.end(); iter++) for (auto iter = joinable_servers.begin(); iter != joinable_servers.end(); iter++)
{ {
auto joinable = *iter; MariaDBServer* joinable = *iter;
const char* name = joinable->server_base->server->unique_name; const char* name = joinable->server_base->server->unique_name;
bool op_success; bool op_success;
@ -378,7 +377,7 @@ uint32_t MariaDBMonitor::do_rejoin(const ServerRefArray& joinable_servers)
*/ */
bool MariaDBMonitor::cluster_can_be_joined() bool MariaDBMonitor::cluster_can_be_joined()
{ {
return (m_master != NULL && SERVER_IS_MASTER(m_master->server) && m_master_gtid_domain >= 0); return (m_master != NULL && SERVER_IS_MASTER(m_master->server_base->server) && m_master_gtid_domain >= 0);
} }
/** /**
@ -393,14 +392,13 @@ bool MariaDBMonitor::cluster_can_be_joined()
bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output) bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output)
{ {
ss_dassert(output); ss_dassert(output);
MariaDBServer* master = get_server_info(m_master);
// Whether a join operation should be attempted or not depends on several criteria. Start with the ones // Whether a join operation should be attempted or not depends on several criteria. Start with the ones
// easiest to test. Go though all slaves and construct a preliminary list. // easiest to test. Go though all slaves and construct a preliminary list.
ServerRefArray suspects; ServerRefArray suspects;
for (size_t i = 0; i < m_servers.size(); i++) for (size_t i = 0; i < m_servers.size(); i++)
{ {
if (server_is_rejoin_suspect(&m_servers[i], master, NULL)) if (server_is_rejoin_suspect(&m_servers[i], m_master, NULL))
{ {
suspects.push_back(&m_servers[i]); suspects.push_back(&m_servers[i]);
} }
@ -410,11 +408,11 @@ bool MariaDBMonitor::get_joinable_servers(ServerRefArray* output)
bool comm_ok = true; bool comm_ok = true;
if (!suspects.empty()) if (!suspects.empty())
{ {
if (master->update_gtids()) if (m_master->update_gtids())
{ {
for (size_t i = 0; i < suspects.size(); i++) for (size_t i = 0; i < suspects.size(); i++)
{ {
if (can_replicate_from(suspects[i], master)) if (can_replicate_from(suspects[i], m_master))
{ {
output->push_back(suspects[i]); output->push_back(suspects[i]);
} }
@ -508,8 +506,8 @@ bool MariaDBMonitor::server_is_rejoin_suspect(MariaDBServer* rejoin_cand, MariaD
} }
// or is disconnected but master host or port is wrong. // or is disconnected but master host or port is wrong.
else if (!slave_status->slave_io_running && slave_status->slave_sql_running && else if (!slave_status->slave_io_running && slave_status->slave_sql_running &&
(slave_status->master_host != m_master->server->name || (slave_status->master_host != m_master->server_base->server->name ||
slave_status->master_port != m_master->server->port)) slave_status->master_port != m_master->server_base->server->port))
{ {
is_suspect = true; is_suspect = true;
} }
@ -542,9 +540,9 @@ bool MariaDBMonitor::do_switchover(MariaDBServer** current_master, MariaDBServer
if (*current_master == NULL) if (*current_master == NULL)
{ {
// Autoselect current master. // Autoselect current master.
if (m_master && SERVER_IS_MASTER(m_master->server)) if (m_master && SERVER_IS_MASTER(m_master->server_base->server))
{ {
demotion_target = get_server_info(m_master); demotion_target = m_master;
*current_master = demotion_target; *current_master = demotion_target;
} }
else else
@ -1176,7 +1174,7 @@ MariaDBServer* MariaDBMonitor::select_new_master(ServerRefArray* slaves_out, jso
* If master is replicating from external master, it is updated by update_slave_info() * If master is replicating from external master, it is updated by update_slave_info()
* but not added to array. */ * but not added to array. */
MariaDBServer* cand = update_slave_info(iter->server_base); MariaDBServer* cand = update_slave_info(iter->server_base);
if (cand && cand->server_base != m_master) if (cand && cand != m_master)
{ {
slaves_out->push_back(cand); slaves_out->push_back(cand);
// Check that server is not in the exclusion list while still being a valid choice. // Check that server is not in the exclusion list while still being a valid choice.
@ -1461,7 +1459,7 @@ bool MariaDBMonitor::mon_process_failover(bool* cluster_modified_out)
{ {
ss_dassert(*cluster_modified_out == false); ss_dassert(*cluster_modified_out == false);
if (config_get_global_options()->passive || if (config_get_global_options()->passive ||
(m_master && SERVER_IS_MASTER(m_master->server))) (m_master && SERVER_IS_MASTER(m_master->server_base->server)))
{ {
return true; return true;
} }
@ -1583,7 +1581,7 @@ bool MariaDBMonitor::slave_receiving_events()
{ {
ss_dassert(m_master); ss_dassert(m_master);
bool received_event = false; bool received_event = false;
int64_t master_id = m_master->server->node_id; int64_t master_id = m_master->server_base->server->node_id;
for (MXS_MONITORED_SERVER* server = m_monitor_base->monitored_servers; server; server = server->next) for (MXS_MONITORED_SERVER* server = m_monitor_base->monitored_servers; server; server = server->next)
{ {
MariaDBServer* info = get_server_info(server); MariaDBServer* info = get_server_info(server);

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

@ -378,7 +378,7 @@ void MariaDBMonitor::main_loop()
return; return;
} }
load_server_journal(m_monitor_base, &m_master); load_journal();
if (m_detect_replication_lag) if (m_detect_replication_lag)
{ {
@ -403,7 +403,7 @@ void MariaDBMonitor::main_loop()
// Use the information to find the so far best master server. // Use the information to find the so far best master server.
root_master = find_root_master(); root_master = find_root_master();
if (m_master != NULL && SERVER_IS_MASTER(m_master->server)) if (m_master != NULL && SERVER_IS_MASTER(m_master->server_base->server))
{ {
// Update cluster-wide values dependant on the current master. // Update cluster-wide values dependant on the current master.
update_gtid_domain(); update_gtid_domain();
@ -438,7 +438,7 @@ void MariaDBMonitor::main_loop()
if (set_standalone_master(m_monitor_base->monitored_servers)) if (set_standalone_master(m_monitor_base->monitored_servers))
{ {
// Update the root_master to point to the standalone master // Update the root_master to point to the standalone master
root_master = get_server_info(m_master); root_master = m_master;
} }
} }
else else
@ -466,7 +466,7 @@ void MariaDBMonitor::main_loop()
} }
} }
ss_dassert(root_master == NULL || root_master->server_base == m_master); ss_dassert(root_master == NULL || root_master == m_master);
ss_dassert(root_master == NULL || ss_dassert(root_master == NULL ||
((root_master->server_base->server->status & (SERVER_SLAVE | SERVER_MASTER)) != ((root_master->server_base->server->status & (SERVER_SLAVE | SERVER_MASTER)) !=
(SERVER_SLAVE | SERVER_MASTER))); (SERVER_SLAVE | SERVER_MASTER)));
@ -505,7 +505,7 @@ void MariaDBMonitor::main_loop()
mon_hangup_failed_servers(m_monitor_base); mon_hangup_failed_servers(m_monitor_base);
servers_status_current_to_pending(m_monitor_base); servers_status_current_to_pending(m_monitor_base);
store_server_journal(m_monitor_base, m_master); store_server_journal(m_monitor_base, m_master->server_base);
release_monitor_servers(m_monitor_base); release_monitor_servers(m_monitor_base);
// Check how much the monitor should sleep to get one full monitor interval. // Check how much the monitor should sleep to get one full monitor interval.
@ -535,26 +535,24 @@ void MariaDBMonitor::main_loop()
void MariaDBMonitor::update_gtid_domain() void MariaDBMonitor::update_gtid_domain()
{ {
MariaDBServer* master_info = get_server_info(m_master); int64_t domain = m_master->gtid_domain_id;
int64_t domain = master_info->gtid_domain_id;
if (m_master_gtid_domain >= 0 && domain != m_master_gtid_domain) if (m_master_gtid_domain >= 0 && domain != m_master_gtid_domain)
{ {
MXS_NOTICE("Gtid domain id of master has changed: %" PRId64 " -> %" PRId64 ".", MXS_NOTICE("Gtid domain id of master has changed: %" PRId64 " -> %" PRId64 ".",
m_master_gtid_domain, domain); m_master_gtid_domain, domain);
} }
m_master_gtid_domain = domain; m_master_gtid_domain = domain;
} }
void MariaDBMonitor::update_external_master() void MariaDBMonitor::update_external_master()
{ {
MariaDBServer* master_info = get_server_info(m_master); if (SERVER_IS_SLAVE_OF_EXTERNAL_MASTER(m_master->server_base->server))
if (SERVER_IS_SLAVE_OF_EXTERNAL_MASTER(m_master->server))
{ {
if (master_info->slave_status.master_host != m_external_master_host || if (m_master->slave_status.master_host != m_external_master_host ||
master_info->slave_status.master_port != m_external_master_port) m_master->slave_status.master_port != m_external_master_port)
{ {
const string new_ext_host = master_info->slave_status.master_host; const string new_ext_host = m_master->slave_status.master_host;
const int new_ext_port = master_info->slave_status.master_port; const int new_ext_port = m_master->slave_status.master_port;
if (m_external_master_port == PORT_UNKNOWN) if (m_external_master_port == PORT_UNKNOWN)
{ {
MXS_NOTICE("Cluster master server is replicating from an external master: %s:%d", MXS_NOTICE("Cluster master server is replicating from an external master: %s:%d",
@ -617,7 +615,7 @@ void MariaDBMonitor::handle_auto_failover(bool* failover_performed)
} }
// If master seems to be down, check if slaves are receiving events. // If master seems to be down, check if slaves are receiving events.
else if (m_verify_master_failure && m_master && else if (m_verify_master_failure && m_master &&
SERVER_IS_DOWN(m_master->server) && slave_receiving_events()) SERVER_IS_DOWN(m_master->server_base->server) && slave_receiving_events())
{ {
MXS_INFO("Master failure not yet confirmed by slaves, delaying failover."); MXS_INFO("Master failure not yet confirmed by slaves, delaying failover.");
} }
@ -687,7 +685,7 @@ void MariaDBMonitor::handle_auto_rejoin()
else else
{ {
MXS_ERROR("Query error to master '%s' prevented a possible rejoin operation.", MXS_ERROR("Query error to master '%s' prevented a possible rejoin operation.",
m_master->server->unique_name); m_master->server_base->server->unique_name);
} }
} }
@ -790,7 +788,7 @@ void MariaDBMonitor::set_master_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(heartbeat_insert_query, sprintf(heartbeat_insert_query,
"UPDATE maxscale_schema.replication_heartbeat " "UPDATE maxscale_schema.replication_heartbeat "
"SET master_timestamp = %lu WHERE master_server_id = %li AND maxscale_id = %lu", "SET master_timestamp = %lu WHERE master_server_id = %li AND maxscale_id = %lu",
heartbeat, m_master->server->node_id, m_id); heartbeat, m_master->server_base->server->node_id, m_id);
/* Try to insert MaxScale timestamp into master */ /* Try to insert MaxScale timestamp into master */
if (mxs_mysql_query(database->con, heartbeat_insert_query)) if (mxs_mysql_query(database->con, heartbeat_insert_query))
@ -810,7 +808,7 @@ void MariaDBMonitor::set_master_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(heartbeat_insert_query, sprintf(heartbeat_insert_query,
"REPLACE INTO maxscale_schema.replication_heartbeat " "REPLACE INTO maxscale_schema.replication_heartbeat "
"(master_server_id, maxscale_id, master_timestamp ) VALUES ( %li, %lu, %lu)", "(master_server_id, maxscale_id, master_timestamp ) VALUES ( %li, %lu, %lu)",
m_master->server->node_id, m_id, heartbeat); m_master->server_base->server->node_id, m_id, heartbeat);
if (mxs_mysql_query(database->con, heartbeat_insert_query)) if (mxs_mysql_query(database->con, heartbeat_insert_query))
{ {
@ -866,7 +864,7 @@ void MariaDBMonitor::set_slave_heartbeat(MXS_MONITORED_SERVER *database)
sprintf(select_heartbeat_query, "SELECT master_timestamp " sprintf(select_heartbeat_query, "SELECT master_timestamp "
"FROM maxscale_schema.replication_heartbeat " "FROM maxscale_schema.replication_heartbeat "
"WHERE maxscale_id = %lu AND master_server_id = %li", "WHERE maxscale_id = %lu AND master_server_id = %li",
m_id, m_master->server->node_id); m_id, m_master->server_base->server->node_id);
/* if there is a master then send the query to the slave with master_id */ /* if there is a master then send the query to the slave with master_id */
if (m_master != NULL && (mxs_mysql_query(database->con, select_heartbeat_query) == 0 if (m_master != NULL && (mxs_mysql_query(database->con, select_heartbeat_query) == 0
@ -927,7 +925,7 @@ void MariaDBMonitor::set_slave_heartbeat(MXS_MONITORED_SERVER *database)
database->server->rlag = MAX_RLAG_NOT_AVAILABLE; database->server->rlag = MAX_RLAG_NOT_AVAILABLE;
database->server->node_ts = 0; database->server->node_ts = 0;
if (m_master->server->node_id < 0) if (m_master->server_base->server->node_id < 0)
{ {
MXS_ERROR("error: replication heartbeat: " MXS_ERROR("error: replication heartbeat: "
"master_server_id NOT available for %s:%i", "master_server_id NOT available for %s:%i",
@ -960,6 +958,17 @@ void MariaDBMonitor::disable_setting(const char* setting)
monitorAddParameters(m_monitor_base, &p); monitorAddParameters(m_monitor_base, &p);
} }
/**
* Loads saved server states. Should only be called once at the beginning of the main loop after server
* creation.
*/
void MariaDBMonitor::load_journal()
{
MXS_MONITORED_SERVER* master_output = NULL;
load_server_journal(m_monitor_base, &master_output);
m_master = master_output ? get_server_info(master_output) : NULL;
}
/** /**
* Start the monitor instance and return the instance data. This function creates a thread to * Start the monitor instance and return the instance data. This function creates a thread to
* execute the monitoring. Use stopMonitor() to stop the thread. * execute the monitoring. Use stopMonitor() to stop the thread.

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

@ -118,7 +118,7 @@ private:
int64_t m_master_gtid_domain; /**< Gtid domain currently used by the master */ int64_t m_master_gtid_domain; /**< Gtid domain currently used by the master */
std::string m_external_master_host; /**< External master host, for fail/switchover */ std::string m_external_master_host; /**< External master host, for fail/switchover */
int m_external_master_port; /**< External master port */ int m_external_master_port; /**< External master port */
MXS_MONITORED_SERVER *m_master; /**< Master server for MySQL Master/Slave replication */ MariaDBServer *m_master; /**< Master server for MySQL Master/Slave replication */
// Replication topology detection settings // Replication topology detection settings
bool m_mysql51_replication; /**< Use MySQL 5.1 replication */ bool m_mysql51_replication; /**< Use MySQL 5.1 replication */
@ -235,6 +235,7 @@ private:
bool wait_cluster_stabilization(MariaDBServer* new_master, const ServerRefArray& slaves, bool wait_cluster_stabilization(MariaDBServer* new_master, const ServerRefArray& slaves,
int seconds_remaining); int seconds_remaining);
void disable_setting(const char* setting); void disable_setting(const char* setting);
void load_journal();
}; };
/** /**