MXS-2271 Remove m_monitor self pointer

include/maxscale/monitor.hh

@@ -336,6 +336,47 @@ protected:
      */
     virtual void server_removed(SERVER* server);
 
+    /**
+     * Get an array of monitored servers. If a server defined in the config setting is not monitored by
+     * this monitor, the returned array will be empty.
+     *
+     * @param key Setting name
+     * @param error_out Set to true if an error occurs
+     * @return Output array
+     */
+    std::vector<MXS_MONITORED_SERVER*> get_monitored_serverlist(const std::string& key, bool* error_out);
+
+    /**
+     * Find the monitored server representing the server.
+     *
+     * @param search_server Server to search for
+     * @return Found monitored server or NULL if not found
+     */
+    MXS_MONITORED_SERVER* get_monitored_server(SERVER* search_server);
+
+    /**
+     * @brief Load a journal of server states
+     *
+     * @param master  Set to point to the current master
+     */
+    void load_server_journal(MXS_MONITORED_SERVER** master);
+
+    /**
+     * @brief Store a journal of server states
+     *
+     * @param master  The current master server or NULL if no master exists
+     */
+    void store_server_journal(MXS_MONITORED_SERVER* master);
+
+    void check_maintenance_requests();
+
+    /**
+     * @brief Hangup connections to failed servers
+     *
+     * Injects hangup events for DCB that are connected to servers that are down.
+     */
+    void hangup_failed_servers();
+
     /**
      * Contains monitor base class settings. Since monitors are stopped before a setting change,
      * the items cannot be modified while a monitor is running. No locking required.
@@ -467,8 +508,6 @@ 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(Monitor* monitor);
-
 bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv);
 bool mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv);
 
@@ -490,15 +529,6 @@ 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 Hangup connections to failed servers
- *
- * Injects hangup events for DCB that are connected to servers that are down.
- *
- * @param monitor Monitor object
- */
-void mon_hangup_failed_servers(Monitor* monitor);
-
 /**
  * @brief Report query errors
  *
@@ -535,45 +565,6 @@ json_t* monitor_list_to_json(const char* host);
  */
 json_t* monitor_relations_to_server(const SERVER* server, const char* host);
 
-/**
- * @brief Store a journal of server states
- *
- * @param monitor Monitor to journal
- * @param master  The current master server or NULL if no master exists
- */
-void store_server_journal(Monitor* monitor, MXS_MONITORED_SERVER* master);
-
-/**
- * @brief Load a journal of server states
- *
- * @param monitor Monitor where journal is loaded
- * @param master  Set to point to the current master
- */
-void load_server_journal(Monitor* monitor, MXS_MONITORED_SERVER** master);
-
-/**
- * Find the monitored server representing the server.
- *
- * @param mon Cluster monitor
- * @param search_server Server to search for
- * @return Found monitored server or NULL if not found
- */
-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
- * the given monitor, the returned array will be empty.
- *
- * @param params Config parameters
- * @param key Setting name
- * @param mon Monitor which should monitor the servers
- * @param error_out Set to true if an error occurs
- * @return Output array
- */
-std::vector<MXS_MONITORED_SERVER*> mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
-                                                          const char* key, const Monitor* mon,
-                                                          bool* error_out);
-
 // Function for waiting one monitor interval
 void monitor_debug_wait();
 
@@ -771,7 +762,6 @@ protected:
      */
     virtual bool immediate_tick_required() const;
 
-    Monitor*              m_monitor;    /**< The generic monitor structure. */
     MXS_MONITORED_SERVER* m_master;     /**< Master server */
 
 private:

server/core/monitor.cc

@@ -1415,9 +1415,9 @@ bool monitor_serialize(const Monitor* monitor)
     return rval;
 }
 
-void mon_hangup_failed_servers(Monitor* monitor)
+void Monitor::hangup_failed_servers()
 {
-    for (MXS_MONITORED_SERVER* ptr : monitor->m_servers)
+    for (MXS_MONITORED_SERVER* ptr : m_servers)
     {
         if (mon_status_changed(ptr) && (!(ptr->server->is_usable()) || !(ptr->server->is_in_cluster())))
         {
@@ -1438,17 +1438,15 @@ void mon_report_query_error(MXS_MONITORED_SERVER* db)
 /**
  * Check if admin is requesting setting or clearing maintenance status on the server and act accordingly.
  * Should be called at the beginning of a monitor loop.
- *
- * @param monitor The target monitor
  */
-void monitor_check_maintenance_requests(Monitor* monitor)
+void Monitor::check_maintenance_requests()
 {
     /* 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. */
-    int flags_changed = atomic_exchange_int(&monitor->check_status_flag, Monitor::STATUS_FLAG_NOCHECK);
+    int flags_changed = atomic_exchange_int(&check_status_flag, Monitor::STATUS_FLAG_NOCHECK);
     if (flags_changed != Monitor::STATUS_FLAG_NOCHECK)
     {
-        for (auto ptr : monitor->m_servers)
+        for (auto ptr : m_servers)
         {
             // The only server status bit the admin may change is the [Maintenance] bit.
             int admin_msg = atomic_exchange_int(&ptr->status_request,
@@ -1937,12 +1935,13 @@ static bool process_data_file(Monitor* monitor,
     return true;
 }
 
-void store_server_journal(Monitor* monitor, MXS_MONITORED_SERVER* master)
+void Monitor::store_server_journal(MXS_MONITORED_SERVER* master)
 {
+    auto monitor = this; // TODO: cleanup later
     /** Calculate how much memory we need to allocate */
     uint32_t size = MMB_LEN_SCHEMA_VERSION + MMB_LEN_CRC32;
 
-    for (MXS_MONITORED_SERVER* db : monitor->m_servers)
+    for (MXS_MONITORED_SERVER* db : m_servers)
     {
         /** Each server is stored as a type byte and a null-terminated string
          * followed by eight byte server status. */
@@ -2001,8 +2000,9 @@ void store_server_journal(Monitor* monitor, MXS_MONITORED_SERVER* master)
     MXS_FREE(data);
 }
 
-void load_server_journal(Monitor* monitor, MXS_MONITORED_SERVER** master)
+void Monitor::load_server_journal(MXS_MONITORED_SERVER** master)
 {
+    auto monitor = this; // TODO: cleanup later
     char path[PATH_MAX];
     FILE* file = open_data_file(monitor, path);
 
@@ -2137,45 +2137,43 @@ bool Monitor::journal_is_stale() const
     return is_stale;
 }
 
-MXS_MONITORED_SERVER* mon_get_monitored_server(const Monitor* mon, SERVER* search_server)
+MXS_MONITORED_SERVER* Monitor::get_monitored_server(SERVER* search_server)
 {
-    mxb_assert(mon && search_server);
+    mxb_assert(search_server);
-    for (MXS_MONITORED_SERVER* iter : mon->m_servers)
+    for (const auto iter : m_servers)
     {
         if (iter->server == search_server)
         {
             return iter;
         }
     }
-    return NULL;
+    return nullptr;
 }
 
-std::vector<MXS_MONITORED_SERVER*> mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
+std::vector<MXS_MONITORED_SERVER*> Monitor::get_monitored_serverlist(const string& key, bool* error_out)
-                                                          const char* key, const Monitor* mon,
-                                                          bool* error_out)
 {
     std::vector<MXS_MONITORED_SERVER*> monitored_array;
     // Check that value exists.
-    if (!params->contains(key))
+    if (!parameters.contains(key))
     {
         return monitored_array;
     }
 
     string name_error;
-    auto servers = params->get_server_list(key, &name_error);
+    auto servers = parameters.get_server_list(key, &name_error);
     if (!servers.empty())
     {
         // All servers in the array must be monitored by the given monitor.
         for (auto elem : servers)
         {
-            MXS_MONITORED_SERVER* mon_serv = mon_get_monitored_server(mon, elem);
+            MXS_MONITORED_SERVER* mon_serv = get_monitored_server(elem);
             if (mon_serv)
             {
                 monitored_array.push_back(mon_serv);
             }
             else
             {
-                MXS_ERROR("Server '%s' is not monitored by monitor '%s'.", elem->name(), mon->m_name);
+                MXS_ERROR("Server '%s' is not monitored by monitor '%s'.", elem->name(), m_name);
                 *error_out = true;
             }
         }
@@ -2187,7 +2185,8 @@ std::vector<MXS_MONITORED_SERVER*> mon_config_get_servers(const MXS_CONFIG_PARAM
     }
     else
     {
-        MXS_ERROR("Serverlist setting '%s' contains invalid server name '%s'.", key, name_error.c_str());
+        MXS_ERROR("Serverlist setting '%s' contains invalid server name '%s'.",
+                  key.c_str(), name_error.c_str());
         *error_out = true;
     }
 
@@ -2218,7 +2217,7 @@ const char WRN_REQUEST_OVERWRITTEN[] =
 
 bool Monitor::set_server_status(SERVER* srv, int bit, string* errmsg_out)
 {
-    MXS_MONITORED_SERVER* msrv = mon_get_monitored_server(this, srv);
+    MXS_MONITORED_SERVER* msrv = get_monitored_server(srv);
     mxb_assert(msrv);
 
     if (!msrv)
@@ -2281,7 +2280,7 @@ bool Monitor::set_server_status(SERVER* srv, int bit, string* errmsg_out)
 
 bool Monitor::clear_server_status(SERVER* srv, int bit, string* errmsg_out)
 {
-    MXS_MONITORED_SERVER* msrv = mon_get_monitored_server(this, srv);
+    MXS_MONITORED_SERVER* msrv = get_monitored_server(srv);
     mxb_assert(msrv);
 
     if (!msrv)
@@ -2383,7 +2382,6 @@ namespace maxscale
 
 MonitorWorker::MonitorWorker(const string& name, const string& module)
     : Monitor(name, module)
-    , m_monitor(this)
     , m_master(NULL)
     , m_thread_running(false)
     , m_shutdown(0)
@@ -2770,7 +2768,7 @@ bool MonitorWorker::pre_run()
         m_thread_running.store(true, std::memory_order_release);
         m_semaphore.post();
 
-        load_server_journal(m_monitor, &m_master);
+        load_server_journal(&m_master);
         pre_loop();
         delayed_call(1, &MonitorWorker::call_run_one_tick, this);
     }
@@ -2823,7 +2821,7 @@ bool MonitorWorker::call_run_one_tick(Worker::Call::action_t action)
 
 void MonitorWorker::run_one_tick()
 {
-    monitor_check_maintenance_requests(m_monitor);
+    check_maintenance_requests();
 
     tick();
     mxb::atomic::add(&m_ticks, 1, mxb::atomic::RELAXED);
@@ -2832,8 +2830,8 @@ void MonitorWorker::run_one_tick()
 
     process_state_changes();
 
-    mon_hangup_failed_servers(m_monitor);
+    hangup_failed_servers();
-    store_server_journal(m_monitor, m_master);
+    store_server_journal(m_master);
 }
 
 bool MonitorWorker::immediate_tick_required() const

server/modules/monitor/mariadbmon/mariadbmon.cc

@@ -218,7 +218,7 @@ bool MariaDBMonitor::configure(const MXS_CONFIG_PARAMETER* params)
     m_excluded_servers.clear();
     bool settings_ok = true;
     bool list_error = false;
-    auto excluded = mon_config_get_servers(params, CN_NO_PROMOTE_SERVERS, m_monitor, &list_error);
+    auto excluded = get_monitored_serverlist(CN_NO_PROMOTE_SERVERS, &list_error);
     if (list_error)
     {
         settings_ok = false;