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

Move server querying to MariaDBServer

Browse Source 
The query functions still require the base monitor struct because of
mon_ping_or_connect_to_db().
This commit is contained in:
Esa Korhonen 2018-05-09 11:37:59 +03:00
parent 38647a0c69
commit b92284afc4
5 changed files with 189 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -22,7 +22,6 @@ static bool check_replicate_wild_do_table(MXS_MONITORED_SERVER* database);
static bool check_replicate_wild_ignore_table(MXS_MONITORED_SERVER* database);
static const char HB_TABLE_NAME[] = "maxscale_schema.replication_heartbeat";
static bool report_version_err = true;
/**
* This function computes the replication tree from a set of monitored servers and returns the root server
@ -440,136 +439,6 @@ void MariaDBMonitor::find_graph_cycles()
}
}
/**
* Monitor an individual server. TODO: this will likely end up as method of MariaDBServer class.
*
* @param database The database to probe
*/
void MariaDBMonitor::monitor_database(MariaDBServer* serv_info)
{
MXS_MONITORED_SERVER* database = serv_info->m_server_base;
/* Don't probe servers in maintenance mode */
if (SERVER_IN_MAINT(database->server))
{
return;
}
/** Store previous status */
database->mon_prev_status = database->server->status;
mxs_connect_result_t rval = mon_ping_or_connect_to_db(m_monitor_base, database);
if (rval == MONITOR_CONN_OK)
{
server_clear_status_nolock(database->server, SERVER_AUTH_ERROR);
monitor_clear_pending_status(database, SERVER_AUTH_ERROR);
}
else
{
/**
* The current server is not running. Clear all but the stale master bit
* as it is used to detect masters that went down but came up.
*/
unsigned int all_bits = ~SERVER_STALE_STATUS;
server_clear_status_nolock(database->server, all_bits);
monitor_clear_pending_status(database, all_bits);
if (mysql_errno(database->con) == ER_ACCESS_DENIED_ERROR)
{
server_set_status_nolock(database->server, SERVER_AUTH_ERROR);
monitor_set_pending_status(database, SERVER_AUTH_ERROR);
}
/* Log connect failure only once */
if (mon_status_changed(database) && mon_print_fail_status(database))
{
mon_log_connect_error(database, rval);
}
return;
}
/* Store current status in both server and monitor server pending struct */
server_set_status_nolock(database->server, SERVER_RUNNING);
monitor_set_pending_status(database, SERVER_RUNNING);
/* Check whether current server is MaxScale Binlog Server */
MYSQL_RES *result;
if (mxs_mysql_query(database->con, "SELECT @@maxscale_version") == 0 &&
(result = mysql_store_result(database->con)) != NULL)
{
serv_info->m_binlog_relay = true;
mysql_free_result(result);
}
else
{
serv_info->m_binlog_relay = false;
}
/* Get server version string, also get/set numeric representation. */
mxs_mysql_set_server_version(database->con, database->server);
/* Set monitor version enum. */
uint64_t version_num = server_get_version(database->server);
if (version_num >= 100000)
{
serv_info->m_version = MariaDBServer::MARIADB_VERSION_100;
}
else if (version_num >= 5 * 10000 + 5 * 100)
{
serv_info->m_version = MariaDBServer::MARIADB_VERSION_55;
}
else
{
serv_info->m_version = MariaDBServer::MARIADB_VERSION_UNKNOWN;
}
/* Query a few settings. */
serv_info->read_server_variables();
/* If gtid domain exists and server is 10.0, update gtid:s */
if (m_master_gtid_domain >= 0 && serv_info->m_version == MariaDBServer::MARIADB_VERSION_100)
{
serv_info->update_gtids();
}
/* Check for valid server version */
if (serv_info->m_version == MariaDBServer::MARIADB_VERSION_100 ||
serv_info->m_version == MariaDBServer::MARIADB_VERSION_55)
{
monitor_mysql_db(serv_info);
}
else if (report_version_err)
{
MXS_ERROR("MariaDB/MySQL version of server '%s' is less than 5.5, which is not supported. "
"The server is ignored by the monitor.", serv_info->name());
report_version_err = false;
}
}
/**
* Monitor a database with given server info.
*
* @param serv_info Server info for database
*/
void MariaDBMonitor::monitor_mysql_db(MariaDBServer* serv_info)
{
MXS_MONITORED_SERVER* database = serv_info->m_server_base;
/** Clear old states */
monitor_clear_pending_status(database, SERVER_SLAVE | SERVER_MASTER | SERVER_RELAY_MASTER |
SERVER_SLAVE_OF_EXTERNAL_MASTER);
if (serv_info->do_show_slave_status())
{
/* If all configured slaves are running set this node as slave */
if (serv_info->m_n_slaves_running > 0 &&
serv_info->m_n_slaves_running == serv_info->m_slave_status.size())
{
monitor_set_pending_status(database, SERVER_SLAVE);
}
/** Store master_id of current node. */
database->server->master_id = !serv_info->m_slave_status.empty() ?
serv_info->m_slave_status[0].master_server_id : SERVER_ID_UNKNOWN;
}
}
/**
* Check if the maxscale_schema.replication_heartbeat table is replicated on all
* servers and log a warning if problems were found.
@ -863,60 +732,6 @@ bool MariaDBMonitor::set_standalone_master()
return rval;
}
/**
* Monitor a server. Should be moved to the server class later on.
*
* @param server The server
*/
void MariaDBMonitor::monitor_one_server(MariaDBServer& server)
{
MXS_MONITORED_SERVER* ptr = server.m_server_base;
ptr->mon_prev_status = ptr->server->status;
/* copy server status into monitor pending_status */
ptr->pending_status = ptr->server->status;
/* monitor current node */
monitor_database(&server);
if (mon_status_changed(ptr))
{
if (SRV_MASTER_STATUS(ptr->mon_prev_status))
{
/** Master failed, can't recover */
MXS_NOTICE("Server [%s]:%d lost the master status.",
ptr->server->address,
ptr->server->port);
}
}
if (mon_status_changed(ptr))
{
#if defined(SS_DEBUG)
MXS_INFO("Backend server [%s]:%d state : %s",
ptr->server->address,
ptr->server->port,
STRSRVSTATUS(ptr->server));
#else
MXS_DEBUG("Backend server [%s]:%d state : %s",
ptr->server->address,
ptr->server->port,
STRSRVSTATUS(ptr->server));
#endif
}
if (SERVER_IS_DOWN(ptr->server))
{
/** Increase this server'e error count */
ptr->mon_err_count += 1;
}
else
{
/** Reset this server's error count */
ptr->mon_err_count = 0;
}
}
/**
* Compute replication tree, find root master.
*

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

@ -339,7 +339,8 @@ void MariaDBMonitor::main_loop()
// Query all servers for their status.
for (auto iter = m_servers.begin(); iter != m_servers.end(); iter++)
{
monitor_one_server(**iter);
MariaDBServer* server = *iter;
server->update_server(m_monitor_base);
}
// Use the information to find the so far best master server.

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

@ -179,9 +179,6 @@ private:
MariaDBServer* get_server_info(MXS_MONITORED_SERVER* db);
// Cluster discovery and status assignment methods
void monitor_one_server(MariaDBServer& server);
void monitor_database(MariaDBServer* param_db);
void monitor_mysql_db(MariaDBServer *serv_info);
MariaDBServer* find_root_master();
MXS_MONITORED_SERVER* get_replication_tree();
MXS_MONITORED_SERVER* build_mysql51_replication_tree();

174
server/modules/monitor/mariadbmon/mariadbserver.cc
View File

@ -39,6 +39,7 @@ SlaveStatus::SlaveStatus()
MariaDBServer::MariaDBServer(MXS_MONITORED_SERVER* monitored_server)
: m_server_base(monitored_server)
, m_report_version_error(true)
, m_version(MARIADB_VERSION_UNKNOWN)
, m_server_id(SERVER_ID_UNKNOWN)
, m_group(0)
@ -653,6 +654,179 @@ bool MariaDBServer::run_sql_from_file(const string& path, json_t** error_out)
return !error;
}
void MariaDBServer::update_server(MXS_MONITOR* base_monitor)
{
MXS_MONITORED_SERVER* ptr = m_server_base;
ptr->mon_prev_status = ptr->server->status;
/* copy server status into monitor pending_status */
ptr->pending_status = ptr->server->status;
/* monitor current node */
monitor_server(base_monitor);
if (mon_status_changed(ptr))
{
if (SRV_MASTER_STATUS(ptr->mon_prev_status))
{
/** Master failed, can't recover */
MXS_NOTICE("Server [%s]:%d lost the master status.",
ptr->server->address,
ptr->server->port);
}
}
if (mon_status_changed(ptr))
{
#if defined(SS_DEBUG)
MXS_INFO("Backend server [%s]:%d state : %s",
ptr->server->address,
ptr->server->port,
STRSRVSTATUS(ptr->server));
#else
MXS_DEBUG("Backend server [%s]:%d state : %s",
ptr->server->address,
ptr->server->port,
STRSRVSTATUS(ptr->server));
#endif
}
if (SERVER_IS_DOWN(ptr->server))
{
/** Increase this server'e error count */
ptr->mon_err_count += 1;
}
else
{
/** Reset this server's error count */
ptr->mon_err_count = 0;
}
}
/**
* Connect to and query this server.
*
* @param base_monitor The cluster monitor.
*/
void MariaDBServer::monitor_server(MXS_MONITOR* base_monitor)
{
MXS_MONITORED_SERVER* database = m_server_base;
/* Don't probe servers in maintenance mode */
if (SERVER_IN_MAINT(database->server))
{
return;
}
/** Store previous status */
database->mon_prev_status = database->server->status;
mxs_connect_result_t rval = mon_ping_or_connect_to_db(base_monitor, database);
if (rval == MONITOR_CONN_OK)
{
server_clear_status_nolock(database->server, SERVER_AUTH_ERROR);
monitor_clear_pending_status(database, SERVER_AUTH_ERROR);
}
else
{
/**
* The current server is not running. Clear all but the stale master bit
* as it is used to detect masters that went down but came up.
*/
unsigned int all_bits = ~SERVER_STALE_STATUS;
server_clear_status_nolock(database->server, all_bits);
monitor_clear_pending_status(database, all_bits);
if (mysql_errno(database->con) == ER_ACCESS_DENIED_ERROR)
{
server_set_status_nolock(database->server, SERVER_AUTH_ERROR);
monitor_set_pending_status(database, SERVER_AUTH_ERROR);
}
/* Log connect failure only once */
if (mon_status_changed(database) && mon_print_fail_status(database))
{
mon_log_connect_error(database, rval);
}
return;
}
/* Store current status in both server and monitor server pending struct */
server_set_status_nolock(database->server, SERVER_RUNNING);
monitor_set_pending_status(database, SERVER_RUNNING);
/* Check whether current server is MaxScale Binlog Server */
MYSQL_RES *result;
if (mxs_mysql_query(database->con, "SELECT @@maxscale_version") == 0 &&
(result = mysql_store_result(database->con)) != NULL)
{
m_binlog_relay = true;
mysql_free_result(result);
}
else
{
m_binlog_relay = false;
}
/* Get server version string, also get/set numeric representation. */
mxs_mysql_set_server_version(database->con, database->server);
/* Set monitor version enum. */
uint64_t version_num = server_get_version(database->server);
if (version_num >= 100000)
{
m_version = MariaDBServer::MARIADB_VERSION_100;
}
else if (version_num >= 5 * 10000 + 5 * 100)
{
m_version = MariaDBServer::MARIADB_VERSION_55;
}
else
{
m_version = MariaDBServer::MARIADB_VERSION_UNKNOWN;
}
/* Query a few settings. */
read_server_variables();
/* If gtid domain exists and server is 10.0, update gtid:s */
if (m_version == MariaDBServer::MARIADB_VERSION_100)
{
update_gtids();
}
/* Check for valid server version */
if (m_version == MariaDBServer::MARIADB_VERSION_100 || m_version == MariaDBServer::MARIADB_VERSION_55)
{
update_slave_status();
}
else if (m_report_version_error)
{
MXS_ERROR("MariaDB/MySQL version of server '%s' is less than 5.5, which is not supported. "
"The server is ignored by the monitor.", name());
m_report_version_error = false;
}
}
/**
* Update slave status of the server.
*/
void MariaDBServer::update_slave_status()
{
/** Clear old states */
monitor_clear_pending_status(m_server_base, SERVER_SLAVE | SERVER_MASTER | SERVER_RELAY_MASTER |
SERVER_SLAVE_OF_EXTERNAL_MASTER);
if (do_show_slave_status())
{
/* If all configured slaves are running set this node as slave */
if (m_n_slaves_running > 0 && m_n_slaves_running == m_slave_status.size())
{
monitor_set_pending_status(m_server_base, SERVER_SLAVE);
}
/** Store master_id of current node. */
m_server_base->server->master_id = !m_slave_status.empty() ?
m_slave_status[0].master_server_id : SERVER_ID_UNKNOWN;
}
}
SlaveStatus::slave_io_running_t SlaveStatus::slave_io_from_string(const std::string& str)
{
slave_io_running_t rval = SLAVE_IO_NO;

13
server/modules/monitor/mariadbmon/mariadbserver.hh
View File

@ -86,6 +86,7 @@ public:
MXS_MONITORED_SERVER* m_server_base; /**< Monitored server base class/struct. MariaDBServer does not
* own the struct, it is not freed (or connection closed) when
* a MariaDBServer is destroyed. Can be const on gcc 4.8 */
bool m_report_version_error; /**< Report version error for this server. */
mariadb_version m_version; /**< Server version */
int64_t m_server_id; /**< Value of @@server_id. Valid values are 32bit unsigned. */
int m_group; /**< Multi-master group where this server belongs,
@ -282,6 +283,18 @@ public:
* @return True if file was read and all commands were completed successfully
*/
bool run_sql_from_file(const std::string& path, json_t** error_out);
/**
* Query and update information of this server. Sets some values for status bits,
* but these may be added or overridden by later methods.
*
* @param base_monitor The base monitor object monitoring this server. Required for connection settings.
*/
void update_server(MXS_MONITOR* base_monitor);
private:
void monitor_server(MXS_MONITOR* base_monitor);
void update_slave_status();
};
/**