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

MXS-2271 Rename monitor-related classes

Browse Source 
MXS_MONITOR->Monitor
MonitorInstance->MonitorWorker
MonitorInstanceSimple->MonitorWorkerSimple
This commit is contained in:
Esa Korhonen 2019-01-21 16:08:23 +02:00
parent 465f9f16c4
commit 9ac8bf93bb
22 changed files with 204 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/maxscale/modulecmd.hh
View File

@ -96,7 +96,7 @@ struct arg_node
SERVER* server;
MXS_SESSION* session;
DCB* dcb;
MXS_MONITOR* monitor;
Monitor* monitor;
MXS_FILTER_DEF* filter;
} value;
};

60
include/maxscale/monitor.hh
View File

@ -28,7 +28,7 @@
#include <maxscale/server.hh>
#include <maxscale/protocol/mysql.hh>
class MXS_MONITOR;
class Monitor;
struct DCB;
struct json_t;
@ -53,7 +53,7 @@ struct MXS_MONITOR_API
*
* @return Monitor object
*/
MXS_MONITOR* (* createInstance)();
Monitor* (* createInstance)();
};
/**
@ -161,11 +161,11 @@ inline mxb::intrusive_slist_iterator<MXS_MONITORED_SERVER> end(MXS_MONITORED_SER
/**
* Representation of the running monitor.
*/
class MXS_MONITOR
class Monitor
{
public:
MXS_MONITOR();
virtual ~MXS_MONITOR();
Monitor();
virtual ~Monitor();
virtual bool configure(const MXS_CONFIG_PARAMETER* params) = 0;
/**
@ -200,8 +200,8 @@ public:
char* name; /**< Monitor instance name */
std::string module_name; /**< Name of the monitor module */
Monitor* next; /**< Next monitor in the linked list */
MXS_MONITOR* next; /**< Next monitor in the linked list */
mutable std::mutex lock;
bool active = true; /**< True if monitor exists and has not been "destroyed". */
@ -264,7 +264,7 @@ extern const char CN_MONITOR_INTERVAL[];
extern const char CN_SCRIPT[];
extern const char CN_SCRIPT_TIMEOUT[];
bool check_monitor_permissions(MXS_MONITOR* monitor, const char* query);
bool check_monitor_permissions(Monitor* monitor, const char* query);
/**
* Store the current server status to the previous and pending status
@ -290,12 +290,12 @@ void monitor_clear_pending_status(MXS_MONITORED_SERVER* mserver, uint64_t bit);
*/
void monitor_set_pending_status(MXS_MONITORED_SERVER* mserver, uint64_t bit);
void monitor_check_maintenance_requests(MXS_MONITOR* monitor);
void monitor_check_maintenance_requests(Monitor* monitor);
bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv);
bool mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv);
mxs_connect_result_t mon_ping_or_connect_to_db(MXS_MONITOR* mon, MXS_MONITORED_SERVER* database);
mxs_connect_result_t mon_ping_or_connect_to_db(Monitor* mon, MXS_MONITORED_SERVER* database);
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);
@ -313,7 +313,7 @@ const char* mon_get_event_name(mxs_monitor_event_t event);
* @param key Parameter name to alter
* @param value New value for the parameter
*/
void mon_alter_parameter(MXS_MONITOR* monitor, const char* key, const char* value);
void mon_alter_parameter(Monitor* monitor, const char* key, const char* value);
/**
* @brief Handle state change events
@ -325,7 +325,7 @@ void mon_alter_parameter(MXS_MONITOR* monitor, const char* key, const char* valu
* @param script Script to execute or NULL for no script
* @param events Enabled events
*/
void mon_process_state_changes(MXS_MONITOR* monitor, const char* script, uint64_t events);
void mon_process_state_changes(Monitor* monitor, const char* script, uint64_t events);
/**
* @brief Hangup connections to failed servers
@ -334,7 +334,7 @@ void mon_process_state_changes(MXS_MONITOR* monitor, const char* script, uint64_
*
* @param monitor Monitor object
*/
void mon_hangup_failed_servers(MXS_MONITOR* monitor);
void mon_hangup_failed_servers(Monitor* monitor);
/**
* @brief Report query errors
@ -351,7 +351,7 @@ void mon_report_query_error(MXS_MONITORED_SERVER* db);
*
* @return JSON representation of the monitor
*/
json_t* monitor_to_json(const MXS_MONITOR* monitor, const char* host);
json_t* monitor_to_json(const Monitor* monitor, const char* host);
/**
* @brief Convert all monitors to JSON
@ -378,7 +378,7 @@ json_t* monitor_relations_to_server(const SERVER* server, const char* host);
* @param monitor Monitor to journal
* @param master The current master server or NULL if no master exists
*/
void store_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master);
void store_server_journal(Monitor* monitor, MXS_MONITORED_SERVER* master);
/**
* @brief Load a journal of server states
@ -386,7 +386,7 @@ void store_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master);
* @param monitor Monitor where journal is loaded
* @param master Set to point to the current master
*/
void load_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER** master);
void load_server_journal(Monitor* monitor, MXS_MONITORED_SERVER** master);
/**
* Find the monitored server representing the server.
@ -395,7 +395,7 @@ void load_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER** master);
* @param search_server Server to search for
* @return Found monitored server or NULL if not found
*/
MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* search_server);
MXS_MONITORED_SERVER* mon_get_monitored_server(const Monitor* mon, SERVER* search_server);
/**
* Get an array of monitored servers. If a server defined in the config setting is not monitored by
@ -410,7 +410,7 @@ MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* s
*/
int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
const char* key,
const MXS_MONITOR* mon,
const Monitor* mon,
MXS_MONITORED_SERVER*** monitored_array_out);
/**
@ -421,7 +421,7 @@ int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
*
* @return True, if the provided string is valid and the threshold could be set.
*/
bool monitor_set_disk_space_threshold(MXS_MONITOR* monitor, const char* disk_space_threshold);
bool monitor_set_disk_space_threshold(Monitor* monitor, const char* disk_space_threshold);
// Function for waiting one monitor interval
void monitor_debug_wait();
@ -429,14 +429,14 @@ void monitor_debug_wait();
namespace maxscale
{
class MonitorInstance : public MXS_MONITOR
, protected maxbase::Worker
class MonitorWorker : public Monitor
, protected maxbase::Worker
{
public:
MonitorInstance(const MonitorInstance&) = delete;
MonitorInstance& operator=(const MonitorInstance&) = delete;
MonitorWorker(const MonitorWorker&) = delete;
MonitorWorker& operator=(const MonitorWorker&) = delete;
virtual ~MonitorInstance();
virtual ~MonitorWorker();
/**
* @brief Current state of the monitor.
@ -525,7 +525,7 @@ public:
static int64_t get_time_ms();
protected:
MonitorInstance();
MonitorWorker();
/**
* @brief Should the monitor shut down?
@ -625,7 +625,7 @@ protected:
*/
virtual bool immediate_tick_required() const;
MXS_MONITOR* m_monitor; /**< The generic monitor structure. */
Monitor* m_monitor; /**< The generic monitor structure. */
MXS_MONITORED_SERVER* m_master; /**< Master server */
private:
@ -642,14 +642,14 @@ private:
void run_one_tick();
};
class MonitorInstanceSimple : public MonitorInstance
class MonitorWorkerSimple : public MonitorWorker
{
public:
MonitorInstanceSimple(const MonitorInstanceSimple&) = delete;
MonitorInstanceSimple& operator=(const MonitorInstanceSimple&) = delete;
MonitorWorkerSimple(const MonitorWorkerSimple&) = delete;
MonitorWorkerSimple& operator=(const MonitorWorkerSimple&) = delete;
protected:
MonitorInstanceSimple()
MonitorWorkerSimple()
{
}
@ -707,7 +707,7 @@ public:
MonitorApi(const MonitorApi&) = delete;
MonitorApi& operator=(const MonitorApi&) = delete;
static MXS_MONITOR* createInstance()
static Monitor* createInstance()
{
MonitorInstance* pInstance = NULL;
MXS_EXCEPTION_GUARD(pInstance = MonitorInstance::create());

2
server/core/config.cc
View File

@ -3832,7 +3832,7 @@ int create_new_monitor(CONFIG_CONTEXT* obj, std::set<std::string>& monitored_ser
return 1;
}
MXS_MONITOR* monitor = MonitorManager::create_monitor(obj->object, module, obj->parameters);
Monitor* monitor = MonitorManager::create_monitor(obj->object, module, obj->parameters);
if (monitor == NULL)
{
MXS_ERROR("Failed to create monitor '%s'.", obj->object);

20
server/core/config_runtime.cc
View File

@ -137,7 +137,7 @@ bool runtime_link_server(Server* server, const char* target)
bool rval = false;
Service* service = service_internal_find(target);
MXS_MONITOR* monitor = service ? NULL : monitor_find(target);
Monitor* monitor = service ? NULL : monitor_find(target);
if (service)
{
@ -181,7 +181,7 @@ bool runtime_unlink_server(Server* server, const char* target)
bool rval = false;
Service* service = service_internal_find(target);
MXS_MONITOR* monitor = service ? NULL : monitor_find(target);
Monitor* monitor = service ? NULL : monitor_find(target);
if (service || monitor)
{
@ -558,7 +558,7 @@ bool validate_param(const MXS_MODULE_PARAM* basic,
return rval;
}
bool do_alter_monitor(MXS_MONITOR* monitor, const char* key, const char* value)
bool do_alter_monitor(Monitor* monitor, const char* key, const char* value)
{
mxb_assert(monitor->state == MONITOR_STATE_STOPPED);
const MXS_MODULE* mod = get_module(monitor->module_name.c_str(), MODULE_MONITOR);
@ -663,7 +663,7 @@ bool do_alter_monitor(MXS_MONITOR* monitor, const char* key, const char* value)
return success;
}
bool runtime_alter_monitor(MXS_MONITOR* monitor, const char* key, const char* value)
bool runtime_alter_monitor(Monitor* monitor, const char* key, const char* value)
{
// If the monitor is already stopped, don't stop/start it.
bool was_running = (monitor->state == MONITOR_STATE_RUNNING);
@ -1181,7 +1181,7 @@ bool runtime_create_monitor(const char* name, const char* module)
if (monitor_find(name) == NULL)
{
MXS_MONITOR* monitor = monitor_repurpose_destroyed(name, module);
Monitor* monitor = monitor_repurpose_destroyed(name, module);
if (monitor)
{
@ -1363,7 +1363,7 @@ bool runtime_destroy_service(Service* service)
return rval;
}
bool runtime_destroy_monitor(MXS_MONITOR* monitor)
bool runtime_destroy_monitor(Monitor* monitor)
{
bool rval = false;
char filename[PATH_MAX];
@ -2200,9 +2200,9 @@ static bool validate_monitor_json(json_t* json)
return rval;
}
MXS_MONITOR* runtime_create_monitor_from_json(json_t* json)
Monitor* runtime_create_monitor_from_json(json_t* json)
{
MXS_MONITOR* rval = NULL;
Monitor* rval = NULL;
if (validate_object_json(json, {MXS_JSON_PTR_MODULE}, {object_to_server})
&& validate_monitor_json(json))
@ -2358,7 +2358,7 @@ bool service_to_filter_relations(Service* service, json_t* old_json, json_t* new
return rval;
}
bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json)
bool runtime_alter_monitor_from_json(Monitor* monitor, json_t* new_json)
{
bool rval = false;
std::unique_ptr<json_t> old_json(monitor_to_json(monitor, ""));
@ -2416,7 +2416,7 @@ bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json)
return rval;
}
bool runtime_alter_monitor_relationships_from_json(MXS_MONITOR* monitor, json_t* json)
bool runtime_alter_monitor_relationships_from_json(Monitor* monitor, json_t* json)
{
bool rval = false;
std::unique_ptr<json_t> old_json(monitor_to_json(monitor, ""));

10
server/core/internal/config_runtime.hh
View File

@ -141,7 +141,7 @@ bool runtime_enable_server_ssl(Server* server,
* @param value New value
* @return True if @c key was one of the supported parameters
*/
bool runtime_alter_monitor(MXS_MONITOR* monitor, const char* key, const char* value);
bool runtime_alter_monitor(Monitor* monitor, const char* key, const char* value);
/**
* @brief Alter service parameters
@ -252,7 +252,7 @@ bool runtime_destroy_filter(const SFilterDef& filter);
* @param monitor Monitor to destroy
* @return True if monitor was destroyed
*/
bool runtime_destroy_monitor(MXS_MONITOR* monitor);
bool runtime_destroy_monitor(Monitor* monitor);
/**
* Destroy a service
@ -302,7 +302,7 @@ bool runtime_alter_server_relationships_from_json(Server* server, const char* ty
*
* @return Created monitor or NULL on error
*/
MXS_MONITOR* runtime_create_monitor_from_json(json_t* json);
Monitor* runtime_create_monitor_from_json(json_t* json);
/**
* @brief Create a new filter from JSON
@ -330,7 +330,7 @@ Service* runtime_create_service_from_json(json_t* json);
*
* @return True if the monitor was successfully modified to represent @c new_json
*/
bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json);
bool runtime_alter_monitor_from_json(Monitor* monitor, json_t* new_json);
/**
* @brief Alter monitor relationships
@ -340,7 +340,7 @@ bool runtime_alter_monitor_from_json(MXS_MONITOR* monitor, json_t* new_json);
*
* @return True if the relationships were successfully modified
*/
bool runtime_alter_monitor_relationships_from_json(MXS_MONITOR* monitor, json_t* json);
bool runtime_alter_monitor_relationships_from_json(Monitor* monitor, json_t* json);
/**
* @brief Alter a service using JSON

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

@ -95,8 +95,8 @@ public:
* @param module The module name to load
* @return The newly created monitor, or NULL on error
*/
static MXS_MONITOR* create_monitor(const std::string& name, const std::string& module,
MXS_CONFIG_PARAMETER* params);
static Monitor* create_monitor(const std::string& name, const std::string& module,
MXS_CONFIG_PARAMETER* params);
/**
* @brief Destroys all monitors. At this point all monitors should
@ -112,12 +112,12 @@ public:
*
* @param mon The monitor to free
*/
static void destroy_monitor(MXS_MONITOR*);
static void destroy_monitor(Monitor*);
};
void monitor_start(MXS_MONITOR*, const MXS_CONFIG_PARAMETER*);
void monitor_stop(MXS_MONITOR*);
void monitor_start(Monitor*, const MXS_CONFIG_PARAMETER*);
void monitor_stop(Monitor*);
/**
* @brief Mark monitor as deactivated
@ -127,30 +127,30 @@ void monitor_stop(MXS_MONITOR*);
*
* @param monitor
*/
void monitor_deactivate(MXS_MONITOR* monitor);
void monitor_deactivate(Monitor* monitor);
void monitor_stop_all();
void monitor_start_all();
MXS_MONITOR* monitor_find(const char*);
MXS_MONITOR* monitor_repurpose_destroyed(const char* name, const char* module);
Monitor* monitor_find(const char*);
Monitor* monitor_repurpose_destroyed(const char* name, const char* module);
void monitor_show(DCB*, MXS_MONITOR*);
void monitor_show(DCB*, Monitor*);
void monitor_show_all(DCB*);
void monitor_list(DCB*);
bool monitor_add_server(MXS_MONITOR* mon, SERVER* server);
void monitor_remove_server(MXS_MONITOR* mon, SERVER* server);
void monitor_add_user(MXS_MONITOR*, const char*, const char*);
void monitor_add_parameters(MXS_MONITOR* monitor, const MXS_CONFIG_PARAMETER* params);
bool monitor_remove_parameter(MXS_MONITOR* monitor, const char* key);
void monitor_set_parameter(MXS_MONITOR* monitor, const char* key, const char* value);
bool monitor_add_server(Monitor* mon, SERVER* server);
void monitor_remove_server(Monitor* mon, SERVER* server);
void monitor_add_user(Monitor*, const char*, const char*);
void monitor_add_parameters(Monitor* monitor, const MXS_CONFIG_PARAMETER* params);
bool monitor_remove_parameter(Monitor* monitor, const char* key);
void monitor_set_parameter(Monitor* monitor, const char* key, const char* value);
void monitor_set_interval(MXS_MONITOR*, unsigned long);
bool monitor_set_network_timeout(MXS_MONITOR*, int, int, const char*);
void monitor_set_journal_max_age(MXS_MONITOR* mon, time_t value);
void monitor_set_script_timeout(MXS_MONITOR* mon, uint32_t value);
void monitor_set_interval(Monitor*, unsigned long);
bool monitor_set_network_timeout(Monitor*, int, int, const char*);
void monitor_set_journal_max_age(Monitor* mon, time_t value);
void monitor_set_script_timeout(Monitor* mon, uint32_t value);
/**
* @brief Serialize a monitor to a file
@ -160,14 +160,14 @@ void monitor_set_script_timeout(MXS_MONITOR* mon, uint32_t value);
* @param monitor Monitor to serialize
* @return True if serialization was successful
*/
bool monitor_serialize(const MXS_MONITOR* monitor);
bool monitor_serialize(const Monitor* monitor);
/**
* Check if a server is being monitored and return the monitor.
* @param server Server that is queried
* @return The monitor watching this server, or NULL if not monitored
*/
MXS_MONITOR* monitor_server_in_use(const SERVER* server);
Monitor* monitor_server_in_use(const SERVER* server);
/**
* Launch a script
@ -179,7 +179,7 @@ MXS_MONITOR* monitor_server_in_use(const SERVER* server);
*
* @return Return value of the executed script or -1 on error
*/
int monitor_launch_script(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, const char* script, uint32_t timeout);
int monitor_launch_script(Monitor* mon, MXS_MONITORED_SERVER* ptr, const char* script, uint32_t timeout);
/**
* Launch a command
@ -192,4 +192,4 @@ int monitor_launch_script(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, const cha
*
* @return Return value of the executed script or -1 on error.
*/
int monitor_launch_command(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, EXTERNCMD* cmd);
int monitor_launch_command(Monitor* mon, MXS_MONITORED_SERVER* ptr, EXTERNCMD* cmd);

198
server/core/monitor.cc
View File

@ -81,12 +81,12 @@ const char CN_MONITOR_INTERVAL[] = "monitor_interval";
const char CN_SCRIPT[] = "script";
const char CN_SCRIPT_TIMEOUT[] = "script_timeout";
static MXS_MONITOR* allMonitors = NULL;
static Monitor* allMonitors = NULL;
static std::mutex monLock;
static void monitor_server_free_all(MXS_MONITORED_SERVER* servers);
static void remove_server_journal(MXS_MONITOR* monitor);
static bool journal_is_stale(MXS_MONITOR* monitor, time_t max_age);
static void remove_server_journal(Monitor* monitor);
static bool journal_is_stale(Monitor* monitor, time_t max_age);
static const char* monitor_state_to_string(monitor_state_t state);
/** Server type specific bits */
@ -96,7 +96,7 @@ static uint64_t server_type_bits = SERVER_MASTER | SERVER_SLAVE | SERVER_JOINED
static uint64_t all_server_bits = SERVER_RUNNING | SERVER_MAINT | SERVER_MASTER | SERVER_SLAVE
| SERVER_JOINED | SERVER_NDB;
MXS_MONITOR* MonitorManager::create_monitor(const string& name, const string& module,
Monitor* MonitorManager::create_monitor(const string& name, const string& module,
MXS_CONFIG_PARAMETER* params)
{
MXS_MONITOR_API* api = (MXS_MONITOR_API*)load_module(module.c_str(), MODULE_MONITOR);
@ -106,7 +106,7 @@ MXS_MONITOR* MonitorManager::create_monitor(const string& name, const string& mo
return NULL;
}
MXS_MONITOR* mon = api->createInstance();
Monitor* mon = api->createInstance();
if (!mon)
{
MXS_ERROR("Unable to create monitor instance for '%s', using module '%s'.",
@ -132,12 +132,12 @@ MXS_MONITOR* MonitorManager::create_monitor(const string& name, const string& mo
return mon;
}
MXS_MONITOR::MXS_MONITOR()
Monitor::Monitor()
{
memset(journal_hash, 0, sizeof(journal_hash));
}
bool MXS_MONITOR::configure_base(const MXS_CONFIG_PARAMETER* params)
bool Monitor::configure_base(const MXS_CONFIG_PARAMETER* params)
{
read_timeout = config_get_integer(params, CN_BACKEND_READ_TIMEOUT);
write_timeout = config_get_integer(params, CN_BACKEND_WRITE_TIMEOUT);
@ -178,9 +178,9 @@ bool MXS_MONITOR::configure_base(const MXS_CONFIG_PARAMETER* params)
return !error;
}
void MonitorManager::destroy_monitor(MXS_MONITOR* mon)
void MonitorManager::destroy_monitor(Monitor* mon)
{
MXS_MONITOR* ptr;
Monitor* ptr;
std::unique_lock<std::mutex> guard(monLock);
@ -205,7 +205,7 @@ void MonitorManager::destroy_monitor(MXS_MONITOR* mon)
delete mon;
}
MXS_MONITOR::~MXS_MONITOR()
Monitor::~Monitor()
{
delete disk_space_threshold;
config_parameter_free(parameters);
@ -221,7 +221,7 @@ void MonitorManager::destroy_all_monitors()
while (allMonitors)
{
MXS_MONITOR* monitor = allMonitors;
Monitor* monitor = allMonitors;
destroy_monitor(monitor);
}
}
@ -231,7 +231,7 @@ void MonitorManager::destroy_all_monitors()
*
* @param monitor The Monitor that should be started
*/
void monitor_start(MXS_MONITOR* monitor, const MXS_CONFIG_PARAMETER* params)
void monitor_start(Monitor* monitor, const MXS_CONFIG_PARAMETER* params)
{
if (monitor)
{
@ -263,7 +263,7 @@ void monitor_start(MXS_MONITOR* monitor, const MXS_CONFIG_PARAMETER* params)
*/
void monitor_start_all()
{
MXS_MONITOR* ptr;
Monitor* ptr;
std::lock_guard<std::mutex> guard(monLock);
ptr = allMonitors;
@ -282,7 +282,7 @@ void monitor_start_all()
*
* @param monitor The monitor to stop
*/
void monitor_stop(MXS_MONITOR* monitor)
void monitor_stop(Monitor* monitor)
{
if (monitor)
{
@ -307,7 +307,7 @@ void monitor_stop(MXS_MONITOR* monitor)
}
}
void monitor_deactivate(MXS_MONITOR* monitor)
void monitor_deactivate(Monitor* monitor)
{
std::lock_guard<std::mutex> guard(monLock);
monitor->active = false;
@ -320,7 +320,7 @@ void monitor_stop_all()
{
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* monitor = allMonitors; monitor; monitor = monitor->next)
for (Monitor* monitor = allMonitors; monitor; monitor = monitor->next)
{
if (monitor->active)
{
@ -336,7 +336,7 @@ void monitor_stop_all()
* @param mon The Monitor instance
* @param server The Server to add to the monitoring
*/
bool monitor_add_server(MXS_MONITOR* mon, SERVER* server)
bool monitor_add_server(Monitor* mon, SERVER* server)
{
mxb_assert(mon && server);
bool rval = false;
@ -416,7 +416,7 @@ static void monitor_server_free_all(MXS_MONITORED_SERVER* servers)
* @param mon The Monitor instance
* @param server The Server to remove
*/
void monitor_remove_server(MXS_MONITOR* mon, SERVER* server)
void monitor_remove_server(Monitor* mon, SERVER* server)
{
monitor_state_t old_state = mon->state;
@ -468,7 +468,7 @@ void monitor_remove_server(MXS_MONITOR* mon, SERVER* server)
* @param user The default username to use when connecting
* @param passwd The default password associated to the default user.
*/
void monitor_add_user(MXS_MONITOR* mon, const char* user, const char* passwd)
void monitor_add_user(Monitor* mon, const char* user, const char* passwd)
{
if (user != mon->user)
{
@ -490,7 +490,7 @@ void monitor_show_all(DCB* dcb)
{
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* ptr = allMonitors; ptr; ptr = ptr->next)
for (Monitor* ptr = allMonitors; ptr; ptr = ptr->next)
{
if (ptr->active)
{
@ -504,7 +504,7 @@ void monitor_show_all(DCB* dcb)
*
* @param dcb DCB for printing output
*/
void monitor_show(DCB* dcb, MXS_MONITOR* monitor)
void monitor_show(DCB* dcb, Monitor* monitor)
{
dcb_printf(dcb, "Monitor: %p\n", monitor);
dcb_printf(dcb, "Name: %s\n", monitor->name);
@ -545,7 +545,7 @@ void monitor_show(DCB* dcb, MXS_MONITOR* monitor)
*/
void monitor_list(DCB* dcb)
{
MXS_MONITOR* ptr;
Monitor* ptr;
std::lock_guard<std::mutex> guard(monLock);
ptr = allMonitors;
@ -573,11 +573,11 @@ void monitor_list(DCB* dcb)
* @param name The name of the monitor
* @return Pointer to the monitor or NULL
*/
MXS_MONITOR* monitor_find(const char* name)
Monitor* monitor_find(const char* name)
{
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* ptr = allMonitors; ptr; ptr = ptr->next)
for (Monitor* ptr = allMonitors; ptr; ptr = ptr->next)
{
if (!strcmp(ptr->name, name) && ptr->active)
{
@ -593,12 +593,12 @@ MXS_MONITOR* monitor_find(const char* name)
* @param name The name of the monitor
* @return Pointer to the destroyed monitor or NULL if monitor is not found
*/
MXS_MONITOR* monitor_repurpose_destroyed(const char* name, const char* module)
Monitor* monitor_repurpose_destroyed(const char* name, const char* module)
{
MXS_MONITOR* rval = NULL;
Monitor* rval = NULL;
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* ptr = allMonitors; ptr; ptr = ptr->next)
for (Monitor* ptr = allMonitors; ptr; ptr = ptr->next)
{
if (strcmp(ptr->name, name) == 0 && (ptr->module_name == module))
{
@ -617,7 +617,7 @@ MXS_MONITOR* monitor_repurpose_destroyed(const char* name, const char* module)
* @param mon The monitor instance
* @param interval The sampling interval in milliseconds
*/
void monitor_set_interval(MXS_MONITOR* mon, unsigned long interval)
void monitor_set_interval(Monitor* mon, unsigned long interval)
{
mon->interval = interval;
}
@ -628,12 +628,12 @@ void monitor_set_interval(MXS_MONITOR* mon, unsigned long interval)
* @param mon The monitor instance
* @param interval The journal age in seconds
*/
void monitor_set_journal_max_age(MXS_MONITOR* mon, time_t value)
void monitor_set_journal_max_age(Monitor* mon, time_t value)
{
mon->journal_max_age = value;
}
void monitor_set_script_timeout(MXS_MONITOR* mon, uint32_t value)
void monitor_set_script_timeout(Monitor* mon, uint32_t value)
{
mon->script_timeout = value;
}
@ -645,7 +645,7 @@ void monitor_set_script_timeout(MXS_MONITOR* mon, uint32_t value)
* @param type The timeout handling type
* @param value The timeout to set
*/
bool monitor_set_network_timeout(MXS_MONITOR* mon, int type, int value, const char* key)
bool monitor_set_network_timeout(Monitor* mon, int type, int value, const char* key)
{
bool rval = true;
@ -694,7 +694,7 @@ std::unique_ptr<ResultSet> monitor_get_list()
std::unique_ptr<ResultSet> set = ResultSet::create({"Monitor", "Status"});
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* ptr = allMonitors; ptr; ptr = ptr->next)
for (Monitor* ptr = allMonitors; ptr; ptr = ptr->next)
{
const char* state = ptr->state & MONITOR_STATE_RUNNING ? "Running" : "Stopped";
set->add_row({ptr->name, state});
@ -710,7 +710,7 @@ std::unique_ptr<ResultSet> monitor_get_list()
* @param query Query to execute
* @return True on success, false if monitor credentials lack permissions
*/
bool check_monitor_permissions(MXS_MONITOR* monitor, const char* query)
bool check_monitor_permissions(Monitor* monitor, const char* query)
{
if (monitor->monitored_servers == NULL // No servers to check
|| config_get_global_options()->skip_permission_checks)
@ -795,7 +795,7 @@ bool check_monitor_permissions(MXS_MONITOR* monitor, const char* query)
* @param monitor Monitor
* @param params Config parameters
*/
void monitor_add_parameters(MXS_MONITOR* monitor, const MXS_CONFIG_PARAMETER* params)
void monitor_add_parameters(Monitor* monitor, const MXS_CONFIG_PARAMETER* params)
{
Guard guard(monitor->lock);
while (params)
@ -818,7 +818,7 @@ void monitor_add_parameters(MXS_MONITOR* monitor, const MXS_CONFIG_PARAMETER* pa
}
}
void monitor_set_parameter(MXS_MONITOR* monitor, const char* key, const char* value)
void monitor_set_parameter(Monitor* monitor, const char* key, const char* value)
{
monitor_remove_parameter(monitor, key);
MXS_CONFIG_PARAMETER p = {};
@ -827,7 +827,7 @@ void monitor_set_parameter(MXS_MONITOR* monitor, const char* key, const char* va
monitor_add_parameters(monitor, &p);
}
bool monitor_remove_parameter(MXS_MONITOR* monitor, const char* key)
bool monitor_remove_parameter(Monitor* monitor, const char* key)
{
MXS_CONFIG_PARAMETER* prev = NULL;
bool rval = false;
@ -858,7 +858,7 @@ bool monitor_remove_parameter(MXS_MONITOR* monitor, const char* key)
return rval;
}
void mon_alter_parameter(MXS_MONITOR* monitor, const char* key, const char* value)
void mon_alter_parameter(Monitor* monitor, const char* key, const char* value)
{
Guard guard(monitor->lock);
for (MXS_CONFIG_PARAMETER* p = monitor->parameters; p; p = p->next)
@ -1060,7 +1060,7 @@ enum credentials_approach_t
* @param len Length of @c dest
* @param approach Whether credentials should be included or not.
*/
static void mon_append_node_names(MXS_MONITOR* mon,
static void mon_append_node_names(Monitor* mon,
char* dest,
int len,
int status,
@ -1212,7 +1212,7 @@ static std::string child_nodes(MXS_MONITORED_SERVER* servers,
return ss.str();
}
int monitor_launch_command(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, EXTERNCMD* cmd)
int monitor_launch_command(Monitor* mon, MXS_MONITORED_SERVER* ptr, EXTERNCMD* cmd)
{
if (externcmd_matches(cmd, "$INITIATOR"))
{
@ -1354,7 +1354,7 @@ int monitor_launch_command(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, EXTERNCM
return rv;
}
int monitor_launch_script(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, const char* script, uint32_t timeout)
int monitor_launch_script(Monitor* mon, MXS_MONITORED_SERVER* ptr, const char* script, uint32_t timeout)
{
char arg[strlen(script) + 1];
strcpy(arg, script);
@ -1385,7 +1385,7 @@ int monitor_launch_script(MXS_MONITOR* mon, MXS_MONITORED_SERVER* ptr, const cha
* @param database Monitored database
* @return Connection status.
*/
mxs_connect_result_t mon_ping_or_connect_to_db(MXS_MONITOR* mon, MXS_MONITORED_SERVER* database)
mxs_connect_result_t mon_ping_or_connect_to_db(Monitor* mon, MXS_MONITORED_SERVER* database)
{
if (database->con)
{
@ -1484,12 +1484,12 @@ static void mon_log_state_change(MXS_MONITORED_SERVER* ptr)
prev.c_str(), next.c_str());
}
MXS_MONITOR* monitor_server_in_use(const SERVER* server)
Monitor* monitor_server_in_use(const SERVER* server)
{
MXS_MONITOR* rval = NULL;
Monitor* rval = NULL;
std::lock_guard<std::mutex> guard(monLock);
for (MXS_MONITOR* mon = allMonitors; mon && !rval; mon = mon->next)
for (Monitor* mon = allMonitors; mon && !rval; mon = mon->next)
{
Guard guard(mon->lock);
if (mon->active)
@ -1507,7 +1507,7 @@ MXS_MONITOR* monitor_server_in_use(const SERVER* server)
return rval;
}
static bool create_monitor_config(const MXS_MONITOR* monitor, const char* filename)
static bool create_monitor_config(const Monitor* monitor, const char* filename)
{
int file = open(filename, O_EXCL | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
@ -1554,7 +1554,7 @@ static bool create_monitor_config(const MXS_MONITOR* monitor, const char* filena
return true;
}
bool monitor_serialize(const MXS_MONITOR* monitor)
bool monitor_serialize(const Monitor* monitor)
{
bool rval = false;
char filename[PATH_MAX];
@ -1596,7 +1596,7 @@ bool monitor_serialize(const MXS_MONITOR* monitor)
return rval;
}
void mon_hangup_failed_servers(MXS_MONITOR* monitor)
void mon_hangup_failed_servers(Monitor* monitor)
{
for (MXS_MONITORED_SERVER* ptr = monitor->monitored_servers; ptr; ptr = ptr->next)
{
@ -1622,7 +1622,7 @@ void mon_report_query_error(MXS_MONITORED_SERVER* db)
*
* @param monitor The target monitor
*/
void monitor_check_maintenance_requests(MXS_MONITOR* monitor)
void monitor_check_maintenance_requests(Monitor* monitor)
{
/* In theory, the admin may be modifying the server maintenance status during this function. The overall
* maintenance flag should be read-written atomically to prevent missing a value. */
@ -1649,7 +1649,7 @@ void monitor_check_maintenance_requests(MXS_MONITOR* monitor)
}
}
void mon_process_state_changes(MXS_MONITOR* monitor, const char* script, uint64_t events)
void mon_process_state_changes(Monitor* monitor, const char* script, uint64_t events)
{
bool master_down = false;
bool master_up = false;
@ -1712,7 +1712,7 @@ static const char* monitor_state_to_string(monitor_state_t state)
}
}
json_t* monitor_parameters_to_json(const MXS_MONITOR* monitor)
json_t* monitor_parameters_to_json(const Monitor* monitor)
{
json_t* rval = json_object();
const MXS_MODULE* mod = get_module(monitor->module_name.c_str(), MODULE_MONITOR);
@ -1724,7 +1724,7 @@ json_t* monitor_parameters_to_json(const MXS_MONITOR* monitor)
return rval;
}
json_t* monitor_json_data(const MXS_MONITOR* monitor, const char* host)
json_t* monitor_json_data(const Monitor* monitor, const char* host)
{
json_t* rval = json_object();
json_t* attr = json_object();
@ -1768,7 +1768,7 @@ json_t* monitor_json_data(const MXS_MONITOR* monitor, const char* host)
return rval;
}
json_t* monitor_to_json(const MXS_MONITOR* monitor, const char* host)
json_t* monitor_to_json(const Monitor* monitor, const char* host)
{
string self = MXS_JSON_API_MONITORS;
self += monitor->name;
@ -1781,7 +1781,7 @@ json_t* monitor_list_to_json(const char* host)
std::unique_lock<std::mutex> guard(monLock);
for (MXS_MONITOR* mon = allMonitors; mon; mon = mon->next)
for (Monitor* mon = allMonitors; mon; mon = mon->next)
{
if (mon->active)
{
@ -1804,7 +1804,7 @@ json_t* monitor_relations_to_server(const SERVER* server, const char* host)
std::vector<std::string> names;
std::unique_lock<std::mutex> guard(monLock);
for (MXS_MONITOR* mon = allMonitors; mon; mon = mon->next)
for (Monitor* mon = allMonitors; mon; mon = mon->next)
{
Guard guard(mon->lock);
if (mon->active)
@ -1847,7 +1847,7 @@ static const char journal_template[] = "%s/%s/%s";
* @param src File to rename
* @return True if file was successfully renamed
*/
static bool rename_tmp_file(MXS_MONITOR* monitor, const char* src)
static bool rename_tmp_file(Monitor* monitor, const char* src)
{
bool rval = true;
char dest[PATH_MAX + 1];
@ -1873,7 +1873,7 @@ static bool rename_tmp_file(MXS_MONITOR* monitor, const char* src)
* @param path Output where the path is stored
* @return Opened file or NULL on error
*/
static FILE* open_tmp_file(MXS_MONITOR* monitor, char* path)
static FILE* open_tmp_file(Monitor* monitor, char* path)
{
int nbytes = snprintf(path, PATH_MAX, journal_template, get_datadir(), monitor->name, "");
int max_bytes = PATH_MAX - (int)sizeof(journal_name);
@ -1913,7 +1913,7 @@ static FILE* open_tmp_file(MXS_MONITOR* monitor, char* path)
* PATH_MAX bytes long
* @param size Size of @c data
*/
static void store_data(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master, uint8_t* data, uint32_t size)
static void store_data(Monitor* monitor, MXS_MONITORED_SERVER* master, uint8_t* data, uint32_t size)
{
uint8_t* ptr = data;
@ -1956,7 +1956,7 @@ static void store_data(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master, uint8
mxb_assert(ptr - data == size + MMB_LEN_BYTES);
}
static int get_data_file_path(MXS_MONITOR* monitor, char* path)
static int get_data_file_path(Monitor* monitor, char* path)
{
int rv = snprintf(path, PATH_MAX, journal_template, get_datadir(), monitor->name, journal_name);
return rv;
@ -1969,7 +1969,7 @@ static int get_data_file_path(MXS_MONITOR* monitor, char* path)
* @param path Output where path is stored
* @return Opened file or NULL on error
*/
static FILE* open_data_file(MXS_MONITOR* monitor, char* path)
static FILE* open_data_file(Monitor* monitor, char* path)
{
FILE* rval = NULL;
int nbytes = get_data_file_path(monitor, path);
@ -2012,7 +2012,7 @@ static bool has_null_terminator(const char* data, const char* end)
/**
* Process a generic server
*/
static const char* process_server(MXS_MONITOR* monitor, const char* data, const char* end)
static const char* process_server(Monitor* monitor, const char* data, const char* end)
{
for (MXS_MONITORED_SERVER* db = monitor->monitored_servers; db; db = db->next)
{
@ -2038,7 +2038,7 @@ static const char* process_server(MXS_MONITOR* monitor, const char* data, const
/**
* Process a master
*/
static const char* process_master(MXS_MONITOR* monitor,
static const char* process_master(Monitor* monitor,
MXS_MONITORED_SERVER** master,
const char* data,
const char* end)
@ -2074,7 +2074,7 @@ static bool check_crc32(const uint8_t* data, uint32_t size, const uint8_t* crc_p
/**
* Process the stored journal data
*/
static bool process_data_file(MXS_MONITOR* monitor,
static bool process_data_file(Monitor* monitor,
MXS_MONITORED_SERVER** master,
const char* data,
const char* crc_ptr)
@ -2116,7 +2116,7 @@ static bool process_data_file(MXS_MONITOR* monitor,
return true;
}
void store_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master)
void store_server_journal(Monitor* monitor, MXS_MONITORED_SERVER* master)
{
/** Calculate how much memory we need to allocate */
uint32_t size = MMB_LEN_SCHEMA_VERSION + MMB_LEN_CRC32;
@ -2180,7 +2180,7 @@ void store_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master)
MXS_FREE(data);
}
void load_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER** master)
void load_server_journal(Monitor* monitor, MXS_MONITORED_SERVER** master)
{
char path[PATH_MAX];
FILE* file = open_data_file(monitor, path);
@ -2264,7 +2264,7 @@ void load_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER** master)
}
}
static void remove_server_journal(MXS_MONITOR* monitor)
static void remove_server_journal(Monitor* monitor)
{
char path[PATH_MAX];
@ -2278,7 +2278,7 @@ static void remove_server_journal(MXS_MONITOR* monitor)
}
}
static bool journal_is_stale(MXS_MONITOR* monitor, time_t max_age)
static bool journal_is_stale(Monitor* monitor, time_t max_age)
{
bool is_stale = true;
char path[PATH_MAX];
@ -2316,7 +2316,7 @@ static bool journal_is_stale(MXS_MONITOR* monitor, time_t max_age)
return is_stale;
}
MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* search_server)
MXS_MONITORED_SERVER* mon_get_monitored_server(const Monitor* mon, SERVER* search_server)
{
mxb_assert(mon && search_server);
for (MXS_MONITORED_SERVER* iter = mon->monitored_servers; iter != NULL; iter = iter->next)
@ -2331,7 +2331,7 @@ MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* s
int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
const char* key,
const MXS_MONITOR* mon,
const Monitor* mon,
MXS_MONITORED_SERVER*** monitored_servers_out)
{
mxb_assert(monitored_servers_out != NULL && *monitored_servers_out == NULL);
@ -2374,7 +2374,7 @@ int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
return found;
}
bool monitor_set_disk_space_threshold(MXS_MONITOR* monitor, const char* disk_space_threshold)
bool monitor_set_disk_space_threshold(Monitor* monitor, const char* disk_space_threshold)
{
mxb_assert(monitor->state == MONITOR_STATE_STOPPED);
MxsDiskSpaceThreshold dst;
@ -2402,16 +2402,16 @@ void monitor_debug_wait()
{
using namespace std::chrono;
std::lock_guard<std::mutex> guard(monLock);
std::map<MXS_MONITOR*, uint64_t> ticks;
std::map<Monitor*, uint64_t> ticks;
// Get tick values for all monitors
for (MXS_MONITOR* mon = allMonitors; mon; mon = mon->next)
for (Monitor* mon = allMonitors; mon; mon = mon->next)
{
ticks[mon] = mxb::atomic::load(&mon->ticks);
}
// Wait for all running monitors to advance at least one tick
for (MXS_MONITOR* mon = allMonitors; mon; mon = mon->next)
for (Monitor* mon = allMonitors; mon; mon = mon->next)
{
if (mon->state == MONITOR_STATE_RUNNING)
{
@ -2429,7 +2429,7 @@ void monitor_debug_wait()
namespace maxscale
{
MonitorInstance::MonitorInstance()
MonitorWorker::MonitorWorker()
: m_monitor(this)
, m_master(NULL)
, m_thread_running(false)
@ -2439,17 +2439,17 @@ MonitorInstance::MonitorInstance()
{
}
MonitorInstance::~MonitorInstance()
MonitorWorker::~MonitorWorker()
{
}
monitor_state_t MonitorInstance::monitor_state() const
monitor_state_t MonitorWorker::monitor_state() const
{
static_assert(sizeof(monitor_state_t) == 4, "Unexpected size for enum");
return (monitor_state_t)atomic_load_uint32((uint32_t*)(&m_monitor->state));
}
void MonitorInstance::stop()
void MonitorWorker::stop()
{
// This should only be called by monitor_stop(). NULL worker is allowed since the main worker may
// not exist during program start/stop.
@ -2464,16 +2464,16 @@ void MonitorInstance::stop()
m_thread_running.store(false, std::memory_order_release);
}
void MonitorInstance::diagnostics(DCB* pDcb) const
void MonitorWorker::diagnostics(DCB* pDcb) const
{
}
json_t* MonitorInstance::diagnostics_json() const
json_t* MonitorWorker::diagnostics_json() const
{
return json_object();
}
bool MonitorInstance::start(const MXS_CONFIG_PARAMETER* pParams)
bool MonitorWorker::start(const MXS_CONFIG_PARAMETER* pParams)
{
// This should only be called by monitor_start(). NULL worker is allowed since the main worker may
// not exist during program start/stop.
@ -2527,7 +2527,7 @@ bool MonitorInstance::start(const MXS_CONFIG_PARAMETER* pParams)
}
// static
int64_t MonitorInstance::get_time_ms()
int64_t MonitorWorker::get_time_ms()
{
timespec t;
@ -2537,7 +2537,7 @@ int64_t MonitorInstance::get_time_ms()
return t.tv_sec * 1000 + (t.tv_nsec / 1000000);
}
bool MonitorInstance::should_update_disk_space_status(const MXS_MONITORED_SERVER* pMs) const
bool MonitorWorker::should_update_disk_space_status(const MXS_MONITORED_SERVER* pMs) const
{
bool should_check = false;
@ -2583,7 +2583,7 @@ bool check_disk_space_exhausted(MXS_MONITORED_SERVER* pMs,
}
}
void MonitorInstance::update_disk_space_status(MXS_MONITORED_SERVER* pMs)
void MonitorWorker::update_disk_space_status(MXS_MONITORED_SERVER* pMs)
{
std::map<std::string, disk::SizesAndName> info;
@ -2686,17 +2686,17 @@ void MonitorInstance::update_disk_space_status(MXS_MONITORED_SERVER* pMs)
}
}
bool MonitorInstance::configure(const MXS_CONFIG_PARAMETER* pParams)
bool MonitorWorker::configure(const MXS_CONFIG_PARAMETER* pParams)
{
return true;
}
bool MonitorInstance::has_sufficient_permissions() const
bool MonitorWorker::has_sufficient_permissions() const
{
return true;
}
void MonitorInstance::flush_server_status()
void MonitorWorker::flush_server_status()
{
for (MXS_MONITORED_SERVER* pMs = m_monitor->monitored_servers; pMs; pMs = pMs->next)
{
@ -2707,15 +2707,15 @@ void MonitorInstance::flush_server_status()
}
}
void MonitorInstanceSimple::pre_tick()
void MonitorWorkerSimple::pre_tick()
{
}
void MonitorInstanceSimple::post_tick()
void MonitorWorkerSimple::post_tick()
{
}
void MonitorInstanceSimple::tick()
void MonitorWorkerSimple::tick()
{
pre_tick();
@ -2790,20 +2790,20 @@ void MonitorInstanceSimple::tick()
post_tick();
}
void MonitorInstance::pre_loop()
void MonitorWorker::pre_loop()
{
}
void MonitorInstance::post_loop()
void MonitorWorker::post_loop()
{
}
void MonitorInstance::process_state_changes()
void MonitorWorker::process_state_changes()
{
mon_process_state_changes(m_monitor, m_monitor->script, m_monitor->events);
}
bool MonitorInstance::pre_run()
bool MonitorWorker::pre_run()
{
bool rv = false;
@ -2816,7 +2816,7 @@ bool MonitorInstance::pre_run()
load_server_journal(m_monitor, &m_master);
pre_loop();
delayed_call(1, &MonitorInstance::call_run_one_tick, this);
delayed_call(1, &MonitorWorker::call_run_one_tick, this);
}
else
{
@ -2828,14 +2828,14 @@ bool MonitorInstance::pre_run()
return rv;
}
void MonitorInstance::post_run()
void MonitorWorker::post_run()
{
post_loop();
mysql_thread_end();
}
bool MonitorInstance::call_run_one_tick(Worker::Call::action_t action)
bool MonitorWorker::call_run_one_tick(Worker::Call::action_t action)
{
/** This is both the minimum sleep between two ticks and also the maximum time between early
* wakeup checks. */
@ -2861,12 +2861,12 @@ bool MonitorInstance::call_run_one_tick(Worker::Call::action_t action)
int64_t delay = ((ms_to_next_call <= 0) || (ms_to_next_call >= base_interval_ms)) ?
base_interval_ms : ms_to_next_call;
delayed_call(delay, &MonitorInstance::call_run_one_tick, this);
delayed_call(delay, &MonitorWorker::call_run_one_tick, this);
}
return false;
}
void MonitorInstance::run_one_tick()
void MonitorWorker::run_one_tick()
{
monitor_check_maintenance_requests(m_monitor);
@ -2881,7 +2881,7 @@ void MonitorInstance::run_one_tick()
store_server_journal(m_monitor, m_master);
}
bool MonitorInstance::immediate_tick_required() const
bool MonitorWorker::immediate_tick_required() const
{
return false;
}
@ -2889,6 +2889,6 @@ bool MonitorInstance::immediate_tick_required() const
MXS_MONITORED_SERVER::MXS_MONITORED_SERVER(SERVER* server)
: server(server)
, disk_space_checked(maxscale::MonitorInstance::get_time_ms()) // Pretend disk space was just checked.
, disk_space_checked(maxscale::MonitorWorker::get_time_ms()) // Pretend disk space was just checked.
{
}

12
server/core/resource.cc
View File

@ -259,14 +259,14 @@ private:
HttpResponse cb_stop_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
monitor_stop(monitor);
return HttpResponse(MHD_HTTP_NO_CONTENT);
}
HttpResponse cb_start_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
monitor_start(monitor, monitor->parameters);
return HttpResponse(MHD_HTTP_NO_CONTENT);
}
@ -384,7 +384,7 @@ HttpResponse cb_create_service_listener(const HttpRequest& request)
HttpResponse cb_alter_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
mxb_assert(monitor && request.get_json());
if (runtime_alter_monitor_from_json(monitor, request.get_json()))
@ -397,7 +397,7 @@ HttpResponse cb_alter_monitor(const HttpRequest& request)
HttpResponse cb_alter_monitor_server_relationship(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
mxb_assert(monitor && request.get_json());
if (runtime_alter_monitor_relationships_from_json(monitor, request.get_json()))
@ -486,7 +486,7 @@ HttpResponse cb_delete_server(const HttpRequest& request)
HttpResponse cb_delete_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
mxb_assert(monitor);
if (runtime_destroy_monitor(monitor))
@ -607,7 +607,7 @@ HttpResponse cb_all_monitors(const HttpRequest& request)
HttpResponse cb_get_monitor(const HttpRequest& request)
{
MXS_MONITOR* monitor = monitor_find(request.uri_part(1).c_str());
Monitor* monitor = monitor_find(request.uri_part(1).c_str());
mxb_assert(monitor);
return HttpResponse(MHD_HTTP_OK, monitor_to_json(monitor, request.host()));
}

4
server/core/server.cc
View File

@ -955,7 +955,7 @@ bool mxs::server_set_status(SERVER* srv, int bit, string* errmsg_out)
/* First check if the server is monitored. This isn't done under a lock
* but the race condition cannot cause significant harm. Monitors are never
* freed so the pointer stays valid. */
MXS_MONITOR* mon = monitor_server_in_use(srv);
Monitor* mon = monitor_server_in_use(srv);
if (mon && mon->state == MONITOR_STATE_RUNNING)
{
/* This server is monitored, in which case modifying any other status bit than Maintenance is
@ -997,7 +997,7 @@ bool mxs::server_clear_status(SERVER* srv, int bit, string* errmsg_out)
{
// See server_set_status().
bool written = false;
MXS_MONITOR* mon = monitor_server_in_use(srv);
Monitor* mon = monitor_server_in_use(srv);
if (mon && mon->state == MONITOR_STATE_RUNNING)
{
if (bit & ~SERVER_MAINT)

2
server/modules/monitor/auroramon/auroramon.hh
View File

@ -19,7 +19,7 @@
* @file auroramon.hh - The Aurora monitor
*/
class AuroraMonitor : public maxscale::MonitorInstanceSimple
class AuroraMonitor : public maxscale::MonitorWorkerSimple
{
public:
AuroraMonitor(const AuroraMonitor&) = delete;

2
server/modules/monitor/clustrixmon/clustrixmonitor.hh
View File

@ -19,7 +19,7 @@
#include "clustrixmembership.hh"
#include "clustrixnode.hh"
class ClustrixMonitor : public maxscale::MonitorInstance
class ClustrixMonitor : public maxscale::MonitorWorker
{
ClustrixMonitor(const ClustrixMonitor&) = delete;
ClustrixMonitor& operator=(const ClustrixMonitor&) = delete;

2
server/modules/monitor/csmon/csmon.hh
View File

@ -15,7 +15,7 @@
#include <maxscale/ccdefs.hh>
#include <maxscale/monitor.hh>
class CsMonitor : public maxscale::MonitorInstanceSimple
class CsMonitor : public maxscale::MonitorWorkerSimple
{
public:
CsMonitor(const CsMonitor&) = delete;

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

@ -85,7 +85,7 @@ void GaleraMonitor::diagnostics(DCB* dcb) const
json_t* GaleraMonitor::diagnostics_json() const
{
json_t* rval = MonitorInstance::diagnostics_json();
json_t* rval = MonitorWorker::diagnostics_json();
json_object_set_new(rval, "disable_master_failback", json_boolean(m_disableMasterFailback));
json_object_set_new(rval, "disable_master_role_setting", json_boolean(m_disableMasterRoleSetting));
json_object_set_new(rval, "root_node_as_master", json_boolean(m_root_node_as_master));

2
server/modules/monitor/galeramon/galeramon.hh
View File

@ -36,7 +36,7 @@ struct GaleraNode
typedef std::unordered_map<MXS_MONITORED_SERVER*, GaleraNode> NodeMap;
class GaleraMonitor : public maxscale::MonitorInstanceSimple
class GaleraMonitor : public maxscale::MonitorWorkerSimple
{
public:
GaleraMonitor(const GaleraMonitor&) = delete;

2
server/modules/monitor/grmon/grmon.hh
View File

@ -19,7 +19,7 @@
* @file grmon.hh A MySQL Group Replication cluster monitor
*/
class GRMon : public maxscale::MonitorInstanceSimple
class GRMon : public maxscale::MonitorWorkerSimple
{
public:
GRMon(const GRMon&) = delete;

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

@ -320,7 +320,7 @@ json_t* MariaDBMonitor::diagnostics_json() const
json_t* MariaDBMonitor::to_json() const
{
json_t* rval = MonitorInstance::diagnostics_json();
json_t* rval = MonitorWorker::diagnostics_json();
json_object_set_new(rval, "master", m_master == NULL ? json_null() : json_string(m_master->name()));
json_object_set_new(rval,
"master_gtid_domain_id",
@ -407,7 +407,7 @@ void MariaDBMonitor::pre_loop()
{
// MonitorInstance reads the journal and has the last known master in its m_master member variable.
// Write the corresponding MariaDBServer into the class-specific m_master variable.
auto journal_master = MonitorInstance::m_master;
auto journal_master = MonitorWorker::m_master;
if (journal_master)
{
// This is somewhat questionable, as the journal only contains status bits but no actual topology
@ -496,12 +496,12 @@ void MariaDBMonitor::tick()
// Before exiting, we need to store the current master into the m_master
// member variable of MonitorInstance so that the right server will be
// stored to the journal.
MonitorInstance::m_master = m_master ? m_master->m_server_base : NULL;
MonitorWorker::m_master = m_master ? m_master->m_server_base : NULL;
}
void MariaDBMonitor::process_state_changes()
{
MonitorInstance::process_state_changes();
MonitorWorker::process_state_changes();
m_cluster_modified = false;
// Check for manual commands
@ -843,7 +843,7 @@ bool handle_manual_switchover(const MODULECMD_ARG* args, json_t** error_out)
}
else
{
MXS_MONITOR* mon = args->argv[0].value.monitor;
Monitor* mon = args->argv[0].value.monitor;
auto handle = static_cast<MariaDBMonitor*>(mon);
SERVER* promotion_server = (args->argc >= 2) ? args->argv[1].value.server : NULL;
SERVER* demotion_server = (args->argc == 3) ? args->argv[2].value.server : NULL;
@ -871,7 +871,7 @@ bool handle_manual_failover(const MODULECMD_ARG* args, json_t** output)
}
else
{
MXS_MONITOR* mon = args->argv[0].value.monitor;
Monitor* mon = args->argv[0].value.monitor;
auto handle = static_cast<MariaDBMonitor*>(mon);
rv = handle->run_manual_failover(output);
}
@ -898,7 +898,7 @@ bool handle_manual_rejoin(const MODULECMD_ARG* args, json_t** output)
}
else
{
MXS_MONITOR* mon = args->argv[0].value.monitor;
Monitor* mon = args->argv[0].value.monitor;
SERVER* server = args->argv[1].value.server;
auto handle = static_cast<MariaDBMonitor*>(mon);
rv = handle->run_manual_rejoin(server, output);
@ -920,7 +920,7 @@ bool handle_manual_reset_replication(const MODULECMD_ARG* args, json_t** output)
}
else
{
MXS_MONITOR* mon = args->argv[0].value.monitor;
Monitor* mon = args->argv[0].value.monitor;
SERVER* server = args->argv[1].value.server;
auto handle = static_cast<MariaDBMonitor*>(mon);
rv = handle->run_manual_reset_replication(server, output);

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

@ -35,7 +35,7 @@ typedef std::unordered_map<int64_t, MariaDBServer*> IdToServerMap;
typedef std::map<int, ServerArray> CycleMap;
// MariaDB Monitor instance data
class MariaDBMonitor : public maxscale::MonitorInstance
class MariaDBMonitor : public maxscale::MonitorWorker
{
private:
MariaDBMonitor(const MariaDBMonitor&) = delete;

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

@ -56,7 +56,7 @@ void MMMonitor::diagnostics(DCB* dcb) const
json_t* MMMonitor::diagnostics_json() const
{
json_t* rval = MonitorInstance::diagnostics_json();
json_t* rval = MonitorWorker::diagnostics_json();
json_object_set_new(rval, "detect_stale_master", json_boolean(m_detectStaleMaster));
return rval;
}
@ -363,7 +363,7 @@ void MMMonitor::post_tick()
MXS_MONITORED_SERVER* MMMonitor::get_current_master()
{
MXS_MONITOR* mon = m_monitor;
Monitor* mon = m_monitor;
MXS_MONITORED_SERVER* ptr;
ptr = mon->monitored_servers;

2
server/modules/monitor/mmmon/mmmon.hh
View File

@ -19,7 +19,7 @@
* @file mmmon.hh - The Multi-Master monitor
*/
class MMMonitor : public maxscale::MonitorInstanceSimple
class MMMonitor : public maxscale::MonitorWorkerSimple
{
public:
MMMonitor(const MMMonitor&) = delete;

2
server/modules/monitor/ndbclustermon/ndbclustermon.hh
View File

@ -19,7 +19,7 @@
* @file ndbcclustermon.hh A NDBC cluster monitor
*/
class NDBCMonitor : public maxscale::MonitorInstanceSimple
class NDBCMonitor : public maxscale::MonitorWorkerSimple
{
public:
NDBCMonitor(const NDBCMonitor&) = delete;

12
server/modules/routing/debugcli/debugcmd.cc
View File

@ -532,7 +532,7 @@ static void shutdown_server()
}
static void shutdown_service(DCB* dcb, SERVICE* service);
static void shutdown_monitor(DCB* dcb, MXS_MONITOR* monitor);
static void shutdown_monitor(DCB* dcb, Monitor* monitor);
static void shutdown_listener(DCB* dcb, SERVICE* service, const char* name)
{
@ -625,7 +625,7 @@ struct subcommand syncoptions[] =
};
static void restart_service(DCB* dcb, SERVICE* service);
static void restart_monitor(DCB* dcb, MXS_MONITOR* monitor);
static void restart_monitor(DCB* dcb, Monitor* monitor);
static void restart_listener(DCB* dcb, SERVICE* service, const char* name)
{
@ -1414,7 +1414,7 @@ static void destroyListener(DCB* dcb, SERVICE* service, const char* name)
}
static void destroyMonitor(DCB* dcb, MXS_MONITOR* monitor)
static void destroyMonitor(DCB* dcb, Monitor* monitor)
{
char name[strlen(monitor->name) + 1];
strcpy(name, monitor->name);
@ -1579,7 +1579,7 @@ static void alterServer(DCB* dcb, Server* server,
}
static void alterMonitor(DCB* dcb,
MXS_MONITOR* monitor,
Monitor* monitor,
char* v1,
char* v2,
char* v3,
@ -2714,7 +2714,7 @@ static void show_qc_all(DCB* dcb)
* @param dcb The DCB to use to print messages
* @param monitor The monitor to shutdown
*/
static void shutdown_monitor(DCB* dcb, MXS_MONITOR* monitor)
static void shutdown_monitor(DCB* dcb, Monitor* monitor)
{
monitor_stop(monitor);
}
@ -2725,7 +2725,7 @@ static void shutdown_monitor(DCB* dcb, MXS_MONITOR* monitor)
* @param dcb The DCB to use to print messages
* @param monitor The monitor to restart
*/
static void restart_monitor(DCB* dcb, MXS_MONITOR* monitor)
static void restart_monitor(DCB* dcb, Monitor* monitor)
{
monitor_start(monitor, monitor->parameters);
}

4
server/modules/routing/maxinfo/maxinfo_exec.cc
View File

@ -503,7 +503,7 @@ void exec_shutdown_monitor(DCB* dcb, MAXINFO_TREE* tree)
char errmsg[120];
if (tree && tree->value)
{
MXS_MONITOR* monitor = monitor_find(tree->value);
Monitor* monitor = monitor_find(tree->value);
if (monitor)
{
monitor_stop(monitor);
@ -612,7 +612,7 @@ void exec_restart_monitor(DCB* dcb, MAXINFO_TREE* tree)
char errmsg[120];
if (tree && tree->value)
{
MXS_MONITOR* monitor = monitor_find(tree->value);
Monitor* monitor = monitor_find(tree->value);
if (monitor)
{
monitor_start(monitor, monitor->parameters);