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

MXS-2271 Move free monitor functions into classes

Browse Source 
Functions are divided to MonitorManager, Monitor, or the monitored
server.
This commit is contained in:
Esa Korhonen 2019-03-06 14:41:06 +02:00
parent 40f24aaaee
commit a8949b2560
13 changed files with 138 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
include/maxscale/monitor.hh
View File

@ -150,8 +150,6 @@ public:
int connect_attempts {1}; /**< How many times a connection is attempted */
};
MXS_MONITORED_SERVER(SERVER* server);
/**
* Maintenance mode request constants.
*/
@ -161,6 +159,37 @@ public:
static const int BEING_DRAINED_OFF = 3;
static const int BEING_DRAINED_ON = 4;
MXS_MONITORED_SERVER(SERVER* server);
/**
* Set pending status bits in the monitor server
*
* @param bits The bits to set for the server
*/
void set_pending_status(uint64_t bits);
/**
* Clear pending status bits in the monitor server
*
* @param bits The bits to clear for the server
*/
void clear_pending_status(uint64_t bits);
/**
* Store the current server status to the previous and pending status
* fields of the monitored server.
*/
void stash_current_status();
bool status_changed();
bool should_print_fail_status();
void log_connect_error(mxs_connect_result_t rval);
/**
* Report query error to log.
*/
void mon_report_query_error();
/**
* Ping or connect to a database. If connection does not exist or ping fails, a new connection is created.
* This will always leave a valid database handle in the database->con pointer, allowing the user to call
@ -484,33 +513,6 @@ extern const char CN_MONITOR_INTERVAL[];
extern const char CN_SCRIPT[];
extern const char CN_SCRIPT_TIMEOUT[];
/**
* Store the current server status to the previous and pending status
* fields of the monitored server.
*
* @param mserver The monitored server to update
*/
void monitor_stash_current_status(MXS_MONITORED_SERVER* ptr);
/**
* Clear pending status bits in the monitor server
*
* @param mserver The monitored server to update
* @param bit The bits to clear for the server
*/
void monitor_clear_pending_status(MXS_MONITORED_SERVER* mserver, uint64_t bit);
/**
* Set pending status bits in the monitor server
*
* @param mserver The monitored server to update
* @param bit The bits to set for the server
*/
void monitor_set_pending_status(MXS_MONITORED_SERVER* mserver, uint64_t bit);
bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv);
bool mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv);
/**
* Ping or connect to a database. If connection does not exist or ping fails, a new connection
* is created. This will always leave a valid database handle in @c *ppCon, allowing the user
@ -526,16 +528,8 @@ mxs_connect_result_t mon_ping_or_connect_to_db(const MXS_MONITORED_SERVER::Conne
SERVER& server, MYSQL** ppConn);
bool mon_connection_is_ok(mxs_connect_result_t connect_result);
void mon_log_connect_error(MXS_MONITORED_SERVER* database, mxs_connect_result_t rval);
const char* mon_get_event_name(mxs_monitor_event_t event);
/**
* @brief Report query errors
*
* @param db Database where the query failed
*/
void mon_report_query_error(MXS_MONITORED_SERVER* db);
/**
* @brief Convert monitor to JSON
*
@ -546,28 +540,6 @@ void mon_report_query_error(MXS_MONITORED_SERVER* db);
*/
json_t* monitor_to_json(const Monitor* monitor, const char* host);
/**
* @brief Convert all monitors to JSON
*
* @param host Hostname of this server
*
* @return JSON array containing all monitors
*/
json_t* monitor_list_to_json(const char* host);
/**
* @brief Get links to monitors that relate to a server
*
* @param server Server to inspect
* @param host Hostname of this server
*
* @return Array of monitor links or NULL if no relations exist
*/
json_t* monitor_relations_to_server(const SERVER* server, const char* host);
// Function for waiting one monitor interval
void monitor_debug_wait();
namespace maxscale
{

22
server/core/internal/monitor.hh
View File

@ -127,6 +127,28 @@ public:
* @param monitor The monitor to stop
*/
static void monitor_stop(Monitor*);
/**
* Get links to monitors that relate to a server.
*
* @param server Server to inspect
* @param host Hostname of this server
* @return Array of monitor links or NULL if no relations exist
*/
static json_t* monitor_relations_to_server(const SERVER* server, const char* host);
/**
* Convert all monitors to JSON.
*
* @param host Hostname of this server
* @return JSON array containing all monitors
*/
static json_t* monitor_list_to_json(const char* host);
/**
* Waits until all running monitors have advanced one tick.
*/
static void monitor_debug_wait();
};

88
server/core/monitor.cc
View File

@ -715,20 +715,20 @@ bool Monitor::test_permissions(const string& query)
return rval;
}
void monitor_stash_current_status(MXS_MONITORED_SERVER* ptr)
void MXS_MONITORED_SERVER::stash_current_status()
{
ptr->mon_prev_status = ptr->server->status;
ptr->pending_status = ptr->server->status;
mon_prev_status = server->status;
pending_status = server->status;
}
void monitor_set_pending_status(MXS_MONITORED_SERVER* ptr, uint64_t bit)
void MXS_MONITORED_SERVER::set_pending_status(uint64_t bits)
{
ptr->pending_status |= bit;
pending_status |= bits;
}
void monitor_clear_pending_status(MXS_MONITORED_SERVER* ptr, uint64_t bit)
void MXS_MONITORED_SERVER::clear_pending_status(uint64_t bits)
{
ptr->pending_status &= ~bit;
pending_status &= ~bits;
}
/*
@ -944,21 +944,20 @@ void Monitor::append_node_names(char* dest, int len, int status, credentials_app
}
/**
* Check if current monitored server status has changed
* Check if current monitored server status has changed.
*
* @param mon_srv The monitored server
* @return true if status has changed or false
* @return true if status has changed
*/
bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv)
bool MXS_MONITORED_SERVER::status_changed()
{
bool rval = false;
/* Previous status is -1 if not yet set */
if (mon_srv->mon_prev_status != static_cast<uint64_t>(-1))
if (mon_prev_status != static_cast<uint64_t>(-1))
{
uint64_t old_status = mon_srv->mon_prev_status & all_server_bits;
uint64_t new_status = mon_srv->server->status & all_server_bits;
uint64_t old_status = mon_prev_status & all_server_bits;
uint64_t new_status = server->status & all_server_bits;
/**
* The state has changed if the relevant state bits are not the same,
@ -977,14 +976,13 @@ bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv)
}
/**
* Check if current monitored server has a loggable failure status
* Check if current monitored server has a loggable failure status.
*
* @param mon_srv The monitored server
* @return true if failed status can be logged or false
* @return true if failed status can be logged or false
*/
bool mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv)
bool MXS_MONITORED_SERVER::should_print_fail_status()
{
return mon_srv->server->is_down() && mon_srv->mon_err_count == 0;
return server->is_down() && mon_err_count == 0;
}
static MXS_MONITORED_SERVER* find_parent_node(const std::vector<MXS_MONITORED_SERVER*>& servers,
@ -1279,20 +1277,18 @@ bool mon_connection_is_ok(mxs_connect_result_t connect_result)
/**
* Log an error about the failure to connect to a backend server and why it happened.
*
* @param database Backend database
* @param rval Return value of mon_ping_or_connect_to_db
*/
void mon_log_connect_error(MXS_MONITORED_SERVER* database, mxs_connect_result_t rval)
void MXS_MONITORED_SERVER::log_connect_error(mxs_connect_result_t rval)
{
mxb_assert(!mon_connection_is_ok(rval) && database);
mxb_assert(!mon_connection_is_ok(rval));
const char TIMED_OUT[] = "Monitor timed out when connecting to server %s[%s:%d] : '%s'";
const char REFUSED[] = "Monitor was unable to connect to server %s[%s:%d] : '%s'";
auto srv = database->server;
MXS_ERROR(rval == MONITOR_CONN_TIMEOUT ? TIMED_OUT : REFUSED,
srv->name(),
srv->address,
srv->port,
mysql_error(database->con));
server->name(),
server->address,
server->port,
mysql_error(con));
}
static void mon_log_state_change(MXS_MONITORED_SERVER* ptr)
@ -1419,20 +1415,20 @@ void Monitor::hangup_failed_servers()
{
for (MXS_MONITORED_SERVER* ptr : m_servers)
{
if (mon_status_changed(ptr) && (!(ptr->server->is_usable()) || !(ptr->server->is_in_cluster())))
if (ptr->status_changed() && (!(ptr->server->is_usable()) || !(ptr->server->is_in_cluster())))
{
dcb_hangup_foreach(ptr->server);
}
}
}
void mon_report_query_error(MXS_MONITORED_SERVER* db)
void MXS_MONITORED_SERVER::mon_report_query_error()
{
MXS_ERROR("Failed to execute query on server '%s' ([%s]:%d): %s",
db->server->name(),
db->server->address,
db->server->port,
mysql_error(db->con));
server->name(),
server->address,
server->port,
mysql_error(con));
}
/**
@ -1488,7 +1484,7 @@ void Monitor::detect_handle_state_changes()
for (MXS_MONITORED_SERVER* ptr : m_servers)
{
if (mon_status_changed(ptr))
if (ptr->status_changed())
{
/**
* The last executed event will be needed if a passive MaxScale is
@ -1604,7 +1600,7 @@ json_t* monitor_to_json(const Monitor* monitor, const char* host)
return mxs_json_resource(host, self.c_str(), monitor_json_data(monitor, host));
}
json_t* monitor_list_to_json(const char* host)
json_t* MonitorManager::monitor_list_to_json(const char* host)
{
json_t* rval = json_array();
this_unit.foreach_monitor([rval, host](Monitor* mon) {
@ -1623,7 +1619,7 @@ json_t* monitor_list_to_json(const char* host)
return mxs_json_resource(host, MXS_JSON_API_MONITORS, rval);
}
json_t* monitor_relations_to_server(const SERVER* server, const char* host)
json_t* MonitorManager::monitor_relations_to_server(const SERVER* server, const char* host)
{
std::vector<std::string> names;
this_unit.foreach_monitor([&names, server](Monitor* mon) {
@ -1844,7 +1840,7 @@ static const char* process_server(Monitor* monitor, const char* data, const char
uint64_t status = maxscale::get_byteN(sptr, MMB_LEN_SERVER_STATUS);
db->mon_prev_status = status;
db->server->set_status(status);
monitor_set_pending_status(db, status);
db->set_pending_status(status);
break;
}
}
@ -2346,7 +2342,7 @@ void Monitor::populate_services()
}
}
void monitor_debug_wait()
void MonitorManager::monitor_debug_wait()
{
using namespace std::chrono;
std::map<Monitor*, uint64_t> ticks;
@ -2684,8 +2680,8 @@ void MonitorWorkerSimple::tick()
if (mon_connection_is_ok(rval))
{
monitor_clear_pending_status(pMs, SERVER_AUTH_ERROR);
monitor_set_pending_status(pMs, SERVER_RUNNING);
pMs->clear_pending_status(SERVER_AUTH_ERROR);
pMs->set_pending_status(SERVER_RUNNING);
if (should_update_disk_space_status(pMs))
{
@ -2703,25 +2699,25 @@ void MonitorWorkerSimple::tick()
*/
const uint64_t bits_to_clear = ~SERVER_WAS_MASTER;
monitor_clear_pending_status(pMs, bits_to_clear);
pMs->clear_pending_status(bits_to_clear);
if (mysql_errno(pMs->con) == ER_ACCESS_DENIED_ERROR)
{
monitor_set_pending_status(pMs, SERVER_AUTH_ERROR);
pMs->set_pending_status(SERVER_AUTH_ERROR);
}
else
{
monitor_clear_pending_status(pMs, SERVER_AUTH_ERROR);
pMs->clear_pending_status(SERVER_AUTH_ERROR);
}
if (mon_status_changed(pMs) && mon_print_fail_status(pMs))
if (pMs->status_changed() && pMs->should_print_fail_status())
{
mon_log_connect_error(pMs, rval);
pMs->log_connect_error(rval);
}
}
#if defined (SS_DEBUG)
if (mon_status_changed(pMs) || mon_print_fail_status(pMs))
if (pMs->status_changed() || pMs->should_print_fail_status())
{
// The current status is still in pMs->pending_status.
MXS_DEBUG("Backend server [%s]:%d state : %s",

4
server/core/resource.cc
View File

@ -608,7 +608,7 @@ HttpResponse cb_get_filter(const HttpRequest& request)
HttpResponse cb_all_monitors(const HttpRequest& request)
{
return HttpResponse(MHD_HTTP_OK, monitor_list_to_json(request.host()));
return HttpResponse(MHD_HTTP_OK, MonitorManager::monitor_list_to_json(request.host()));
}
HttpResponse cb_get_monitor(const HttpRequest& request)
@ -742,7 +742,7 @@ HttpResponse cb_unix_user(const HttpRequest& request)
HttpResponse cb_monitor_wait(const HttpRequest& request)
{
monitor_debug_wait();
MonitorManager::monitor_debug_wait();
return HttpResponse(MHD_HTTP_OK);
}
HttpResponse cb_create_user(const HttpRequest& request)

2
server/core/server.cc
View File

@ -1087,7 +1087,7 @@ static json_t* server_to_json_data(const Server* server, const char* host)
/** Relationships */
json_t* rel = json_object();
json_t* service_rel = service_relations_to_server(server, host);
json_t* monitor_rel = monitor_relations_to_server(server, host);
json_t* monitor_rel = MonitorManager::monitor_relations_to_server(server, host);
if (service_rel)
{

6
server/modules/monitor/auroramon/auroramon.cc
View File

@ -57,7 +57,7 @@ bool AuroraMonitor::has_sufficient_permissions()
*/
void AuroraMonitor::update_server_status(MXS_MONITORED_SERVER* monitored_server)
{
monitor_clear_pending_status(monitored_server, SERVER_MASTER | SERVER_SLAVE);
monitored_server->clear_pending_status(SERVER_MASTER | SERVER_SLAVE);
MYSQL_RES* result;
@ -78,12 +78,12 @@ void AuroraMonitor::update_server_status(MXS_MONITORED_SERVER* monitored_server)
status = SERVER_MASTER;
}
monitor_set_pending_status(monitored_server, status);
monitored_server->set_pending_status(status);
mysql_free_result(result);
}
else
{
mon_report_query_error(monitored_server);
monitored_server->mon_report_query_error();
}
}

8
server/modules/monitor/clustrixmon/clustrixmonitor.cc
View File

@ -566,7 +566,7 @@ void ClustrixMonitor::update_server_statuses()
for (auto ms : m_servers)
{
monitor_stash_current_status(ms);
ms->stash_current_status();
auto it = find_if(m_nodes.begin(), m_nodes.end(),
[ms](const std::pair<int,ClustrixNode>& element) -> bool {
@ -580,16 +580,16 @@ void ClustrixMonitor::update_server_statuses()
if (info.is_running())
{
monitor_set_pending_status(ms, SERVER_RUNNING);
ms->set_pending_status(SERVER_RUNNING);
}
else
{
monitor_clear_pending_status(ms, SERVER_RUNNING);
ms->clear_pending_status(SERVER_RUNNING);
}
}
else
{
monitor_clear_pending_status(ms, SERVER_RUNNING);
ms->clear_pending_status(SERVER_RUNNING);
}
}
}

6
server/modules/monitor/csmon/csmon.cc
View File

@ -47,7 +47,7 @@ static std::string do_query(MXS_MONITORED_SERVER* srv, const char* query)
}
else
{
mon_report_query_error(srv);
srv->mon_report_query_error();
}
return rval;
@ -95,7 +95,7 @@ bool CsMonitor::has_sufficient_permissions()
void CsMonitor::update_server_status(MXS_MONITORED_SERVER* srv)
{
monitor_clear_pending_status(srv, SERVER_MASTER | SERVER_SLAVE | SERVER_RUNNING);
srv->clear_pending_status(SERVER_MASTER | SERVER_SLAVE | SERVER_RUNNING);
int status = 0;
if (do_query(srv, alive_query) == "1")
@ -114,7 +114,7 @@ void CsMonitor::update_server_status(MXS_MONITORED_SERVER* srv)
}
}
monitor_set_pending_status(srv, status);
srv->set_pending_status(status);
}
bool CsMonitor::configure(const MXS_CONFIG_PARAMETER* pParams)

28
server/modules/monitor/galeramon/galeramon.cc
View File

@ -224,7 +224,7 @@ void GaleraMonitor::update_server_status(MXS_MONITORED_SERVER* monitored_server)
}
else
{
mon_report_query_error(monitored_server);
monitored_server->mon_report_query_error();
}
}
@ -264,8 +264,8 @@ void GaleraMonitor::post_tick()
if (ptr != m_master)
{
/* set the Slave role and clear master stickiness */
monitor_clear_pending_status(ptr, repl_bits);
monitor_set_pending_status(ptr, SERVER_SLAVE);
ptr->clear_pending_status(repl_bits);
ptr->set_pending_status(SERVER_SLAVE);
}
else
{
@ -273,14 +273,14 @@ void GaleraMonitor::post_tick()
&& m_master->server->node_id != candidate_master->server->node_id)
{
/* set master role and master stickiness */
monitor_clear_pending_status(ptr, repl_bits);
monitor_set_pending_status(ptr, SERVER_MASTER | SERVER_MASTER_STICKINESS);
ptr->clear_pending_status(repl_bits);
ptr->set_pending_status(SERVER_MASTER | SERVER_MASTER_STICKINESS);
}
else
{
/* set master role and clear master stickiness */
monitor_clear_pending_status(ptr, repl_bits);
monitor_set_pending_status(ptr, SERVER_MASTER);
ptr->clear_pending_status(repl_bits);
ptr->set_pending_status(SERVER_MASTER);
}
}
@ -288,8 +288,8 @@ void GaleraMonitor::post_tick()
}
else
{
monitor_clear_pending_status(ptr, repl_bits);
monitor_set_pending_status(ptr, 0);
ptr->clear_pending_status(repl_bits);
ptr->set_pending_status(0);
}
}
@ -348,7 +348,7 @@ static bool using_xtrabackup(MXS_MONITORED_SERVER* database, const char* server_
}
else
{
mon_report_query_error(database);
database->mon_report_query_error();
}
return rval;
@ -569,7 +569,7 @@ void GaleraMonitor::update_sst_donor_nodes(int is_cluster)
}
else
{
mon_report_query_error(ptr);
ptr->mon_report_query_error();
}
}
@ -587,7 +587,7 @@ void GaleraMonitor::update_sst_donor_nodes(int is_cluster)
MXS_MONITORED_SERVER* ptr = node_list[k];
if (mxs_mysql_query(ptr->con, donor_list) != 0)
{
mon_report_query_error(ptr);
ptr->mon_report_query_error();
}
}
@ -713,11 +713,11 @@ void GaleraMonitor::set_galera_cluster()
{
if (it->second.joined)
{
monitor_set_pending_status(it->first, SERVER_JOINED);
it->first->set_pending_status(SERVER_JOINED);
}
else
{
monitor_clear_pending_status(it->first, SERVER_JOINED);
it->first->clear_pending_status(SERVER_JOINED);
}
}
}

16
server/modules/monitor/grmon/grmon.cc
View File

@ -74,7 +74,7 @@ static bool is_master(MXS_MONITORED_SERVER* server)
}
else
{
mon_report_query_error(server);
server->mon_report_query_error();
}
return rval;
@ -101,7 +101,7 @@ static bool is_slave(MXS_MONITORED_SERVER* server)
}
else
{
mon_report_query_error(server);
server->mon_report_query_error();
}
return rval;
@ -111,18 +111,18 @@ void GRMon::update_server_status(MXS_MONITORED_SERVER* monitored_server)
{
if (is_master(monitored_server))
{
monitor_set_pending_status(monitored_server, SERVER_MASTER);
monitor_clear_pending_status(monitored_server, SERVER_SLAVE);
monitored_server->set_pending_status(SERVER_MASTER);
monitored_server->clear_pending_status(SERVER_SLAVE);
}
else if (is_slave(monitored_server))
{
monitor_set_pending_status(monitored_server, SERVER_SLAVE);
monitor_clear_pending_status(monitored_server, SERVER_MASTER);
monitored_server->set_pending_status(SERVER_SLAVE);
monitored_server->clear_pending_status(SERVER_MASTER);
}
else
{
monitor_clear_pending_status(monitored_server, SERVER_SLAVE);
monitor_clear_pending_status(monitored_server, SERVER_MASTER);
monitored_server->clear_pending_status(SERVER_SLAVE);
monitored_server->clear_pending_status(SERVER_MASTER);
}
}

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

@ -406,7 +406,7 @@ void MariaDBMonitor::update_server(MariaDBServer* server)
* iteration. */
if (server->had_status(SERVER_RUNNING) || server->had_status(SERVER_MAINT))
{
mon_log_connect_error(mon_srv, conn_status);
mon_srv->log_connect_error(conn_status);
}
}
@ -657,7 +657,7 @@ void MariaDBMonitor::update_external_master()
void MariaDBMonitor::log_master_changes()
{
MXS_MONITORED_SERVER* root_master = m_master ? m_master->m_server_base : NULL;
if (root_master && mon_status_changed(root_master)
if (root_master && root_master->status_changed()
&& !(root_master->pending_status & SERVER_WAS_MASTER))
{
if ((root_master->pending_status & SERVER_MASTER) && m_master->is_running())

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

@ -991,12 +991,12 @@ void MariaDBServer::check_permissions()
void MariaDBServer::clear_status(uint64_t bits)
{
monitor_clear_pending_status(m_server_base, bits);
m_server_base->clear_pending_status(bits);
}
void MariaDBServer::set_status(uint64_t bits)
{
monitor_set_pending_status(m_server_base, bits);
m_server_base->set_pending_status(bits);
}
/**

8
server/modules/monitor/ndbclustermon/ndbclustermon.cc
View File

@ -76,7 +76,7 @@ void NDBCMonitor::update_server_status(MXS_MONITORED_SERVER* monitored_server)
}
else
{
mon_report_query_error(monitored_server);
monitored_server->mon_report_query_error();
}
/* Check the the SQL node id in the MySQL cluster */
@ -108,16 +108,16 @@ void NDBCMonitor::update_server_status(MXS_MONITORED_SERVER* monitored_server)
}
else
{
mon_report_query_error(monitored_server);
monitored_server->mon_report_query_error();
}
if (isjoined)
{
monitor_set_pending_status(monitored_server, SERVER_NDB);
monitored_server->set_pending_status(SERVER_NDB);
}
else
{
monitor_clear_pending_status(monitored_server, SERVER_NDB);
monitored_server->clear_pending_status(SERVER_NDB);
}
}