Turn server status macros to functions

include/maxscale/backend.hh

@@ -147,7 +147,7 @@ public:
      */
     inline bool can_connect() const
     {
-        return !has_failed() && SERVER_IS_RUNNING(m_backend->server);
+        return !has_failed() && server_is_running(m_backend->server);
     }
 
     /**
@@ -265,7 +265,7 @@ public:
      */
     inline bool is_master() const
     {
-        return SERVER_IS_MASTER(m_backend->server);
+        return server_is_master(m_backend->server);
     }
 
     /**
@@ -275,7 +275,7 @@ public:
      */
     inline bool is_slave() const
     {
-        return SERVER_IS_SLAVE(m_backend->server);
+        return server_is_slave(m_backend->server);
     }
 
     /**
@@ -285,7 +285,7 @@ public:
      */
     inline bool is_relay() const
     {
-        return SERVER_IS_RELAY_SERVER(m_backend->server);
+        return server_is_relay(m_backend->server);
     }
 
     /**

include/maxscale/debug.h

@@ -198,14 +198,14 @@ typedef enum skygw_chk_t
                           ((c) == LEAST_BEHIND_MASTER ? "LEAST_BEHIND_MASTER"           : \
                            ((c) == LEAST_CURRENT_OPERATIONS ? "LEAST_CURRENT_OPERATIONS" : "Unknown criteria")))))
 
-#define STRSRVSTATUS(s) (SERVER_IS_MASTER(s)  ? "RUNNING MASTER" :      \
+#define STRSRVSTATUS(s) (server_is_master(s)  ? "RUNNING MASTER" :      \
-                         (SERVER_IS_SLAVE(s)   ? "RUNNING SLAVE" :      \
+                         (server_is_slave(s)   ? "RUNNING SLAVE" :      \
-                          (SERVER_IS_JOINED(s)  ? "RUNNING JOINED" :    \
+                          (server_is_joined(s)  ? "RUNNING JOINED" :    \
-                           (SERVER_IS_NDB(s)     ? "RUNNING NDB" :      \
+                           (server_is_ndb(s)     ? "RUNNING NDB" :      \
-                            ((!SERVER_IS_DOWN(s) && SERVER_IN_MAINT(s)) ? "RUNNING MAINTENANCE" : \
+                            ((!server_is_down(s) && server_is_in_maint(s)) ? "RUNNING MAINTENANCE" : \
-                             (SERVER_IS_RELAY_SERVER(s) ? "RUNNING RELAY" : \
+                             (server_is_relay(s) ? "RUNNING RELAY" : \
-                              (SERVER_IS_RUNNING(s) ? "RUNNING (only)" : \
+                              (server_is_running(s) ? "RUNNING (only)" : \
-                               (SERVER_IS_DOWN(s) ? "DOWN" : "UNKNOWN STATUS"))))))))
+                               (server_is_down(s) ? "DOWN" : "UNKNOWN STATUS"))))))))
 
 #define STRTARGET(t)    (t == TARGET_ALL ? "TARGET_ALL" :               \
                          (t == TARGET_MASTER ? "TARGET_MASTER" :        \

include/maxscale/server.h

@@ -197,64 +197,98 @@ enum
 /**
  * Is the server valid and active
  */
-#define SERVER_IS_ACTIVE(server) (server->is_active)
+inline bool server_is_active(const SERVER* server)
+{
+    return server->is_active;
+}
 
 /**
- * Is the server running - the macro returns true if the server is marked as running
+ * Is the server running - returns true if the server is marked as running.
- * regardless of it's state as a master or slave
  */
-#define SERVER_IS_RUNNING(server) (((server)->status & (SERVER_RUNNING|SERVER_MAINT)) == SERVER_RUNNING)
+inline bool server_is_running(const SERVER* server)
+{
+    return ((server->status & (SERVER_RUNNING | SERVER_MAINT)) == SERVER_RUNNING);
+}
+
 /**
- * Is the server marked as down - the macro returns true if the server is believed
+ * Is the server marked as down - returns true if the server is believed
  * to be inoperable.
  */
-#define SERVER_IS_DOWN(server)          (((server)->status & SERVER_RUNNING) == 0)
+inline bool server_is_down(const SERVER* server)
-/**
+{
- * Is the server a master? The server must be both running and marked as master
+    return ((server->status & SERVER_RUNNING) == 0);
- * in order for the macro to return true
+}
- */
-#define SERVER_IS_MASTER(server) SRV_MASTER_STATUS((server)->status)
 
-#define SRV_MASTER_STATUS(status) ((status &                            \
+
-                                    (SERVER_RUNNING|SERVER_MASTER|SERVER_MAINT)) == \
+inline bool srv_master_status(uint64_t status)
-                                   (SERVER_RUNNING|SERVER_MASTER))
+{
+    return ((status & (SERVER_RUNNING | SERVER_MASTER | SERVER_MAINT)) == (SERVER_RUNNING | SERVER_MASTER));
+}
+
+/**
+ * Is the server a master? Returns true if server is both running and marked as master.
+ */
+inline bool server_is_master(const SERVER* server)
+{
+    return srv_master_status(server->status);
+}
 
 /**
  * Is the server a slave? The server must be both running and marked as a slave
  * in order for the macro to return true
  */
-#define SERVER_IS_SLAVE(server)                                         \
+inline bool server_is_slave(const SERVER* server)
-    (((server)->status & (SERVER_RUNNING|SERVER_SLAVE|SERVER_MAINT)) == \
+{
-     (SERVER_RUNNING|SERVER_SLAVE))
+    return ((server->status & (SERVER_RUNNING | SERVER_SLAVE | SERVER_MAINT)) ==
+            (SERVER_RUNNING | SERVER_SLAVE));
+}
 
 /**
  * Is the server joined Galera node? The server must be running and joined.
  */
-#define SERVER_IS_JOINED(server)                                        \
+inline bool server_is_joined(const SERVER* server)
-    (((server)->status & (SERVER_RUNNING|SERVER_JOINED|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_JOINED))
+{
+    return ((server->status & (SERVER_RUNNING | SERVER_JOINED | SERVER_MAINT)) ==
+            (SERVER_RUNNING | SERVER_JOINED));
+}
 
 /**
  * Is the server a SQL node in MySQL Cluster? The server must be running and with NDB status
  */
-#define SERVER_IS_NDB(server)                                           \
+inline bool server_is_ndb(const SERVER* server)
-    (((server)->status & (SERVER_RUNNING|SERVER_NDB|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_NDB))
+{
+    return ((server->status & (SERVER_RUNNING | SERVER_NDB | SERVER_MAINT)) == (SERVER_RUNNING | SERVER_NDB));
+}
 
 /**
  * Is the server in maintenance mode.
  */
-#define SERVER_IN_MAINT(server)         ((server)->status & SERVER_MAINT)
+inline bool server_is_in_maint(const SERVER* server)
+{
+    return (server->status & SERVER_MAINT);
+}
 
-#define SERVER_IS_IN_CLUSTER(s)  (((s)->status & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) != 0)
+inline bool server_is_in_cluster(const SERVER* server)
+{
+    return ((server->status & (SERVER_MASTER | SERVER_SLAVE | SERVER_JOINED | SERVER_NDB)) != 0);
+}
 
-#define SERVER_IS_RELAY_SERVER(server)                                  \
+inline bool server_is_relay(const SERVER* server)
-    (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == \
+{
-     (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE))
+    return ((server->status & (SERVER_RUNNING | SERVER_MASTER | SERVER_SLAVE | SERVER_MAINT)) == \
+            (SERVER_RUNNING | SERVER_MASTER | SERVER_SLAVE));
+}
 
-#define SERVER_IS_SLAVE_OF_EXT_MASTER(s) (((s)->status & \
+inline bool server_is_slave_of_ext_master(const SERVER* server)
-    (SERVER_RUNNING|SERVER_SLAVE_OF_EXT_MASTER)) == \
+{
-    (SERVER_RUNNING|SERVER_SLAVE_OF_EXT_MASTER))
+    return ((server->status & (SERVER_RUNNING | SERVER_SLAVE_OF_EXT_MASTER)) ==
+            (SERVER_RUNNING | SERVER_SLAVE_OF_EXT_MASTER));
+}
 
-#define SERVER_IS_DISK_SPACE_EXHAUSTED(s) ((s)->status & SERVER_DISK_SPACE_EXHAUSTED)
+inline bool server_is_disk_space_exhausted(const SERVER* server)
+{
+    return (server->status & SERVER_DISK_SPACE_EXHAUSTED);
+}
 
 /**
  * @brief Allocate a new server

include/maxscale/service.h

@@ -91,7 +91,7 @@ typedef struct server_ref_t
 } SERVER_REF;
 
 /** Macro to check whether a SERVER_REF is active */
-#define SERVER_REF_IS_ACTIVE(ref) (ref->active && SERVER_IS_ACTIVE(ref->server))
+#define SERVER_REF_IS_ACTIVE(ref) (ref->active && server_is_active(ref->server))
 
 #define SERVICE_MAX_RETRY_INTERVAL 3600 /*< The maximum interval between service start retries */
 

server/core/monitor.cc

@@ -1257,7 +1257,7 @@ bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv)
 bool
 mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv)
 {
-    return (SERVER_IS_DOWN(mon_srv->server) && mon_srv->mon_err_count == 0);
+    return (server_is_down(mon_srv->server) && mon_srv->mon_err_count == 0);
 }
 
 static MXS_MONITORED_SERVER* find_parent_node(MXS_MONITORED_SERVER* servers,
@@ -1715,8 +1715,8 @@ void mon_hangup_failed_servers(MXS_MONITOR *monitor)
     for (MXS_MONITORED_SERVER *ptr = monitor->monitored_servers; ptr; ptr = ptr->next)
     {
         if (mon_status_changed(ptr) &&
-            (!(SERVER_IS_RUNNING(ptr->server)) ||
+            (!(server_is_running(ptr->server)) ||
-             !(SERVER_IS_IN_CLUSTER(ptr->server))))
+             !(server_is_in_cluster(ptr->server))))
         {
             dcb_hangup_foreach(ptr->server);
         }
@@ -2830,7 +2830,7 @@ void MonitorInstance::flush_server_status()
 {
     for (MXS_MONITORED_SERVER *pMs = m_monitor->monitored_servers; pMs; pMs = pMs->next)
     {
-        if (!SERVER_IN_MAINT(pMs->server))
+        if (!server_is_in_maint(pMs->server))
         {
             pMs->server->status = pMs->pending_status;
         }
@@ -2851,7 +2851,7 @@ void MonitorInstanceSimple::tick()
 
     for (MXS_MONITORED_SERVER *pMs = m_monitor->monitored_servers; pMs; pMs = pMs->next)
     {
-        if (!SERVER_IN_MAINT(pMs->server))
+        if (!server_is_in_maint(pMs->server))
         {
             pMs->mon_prev_status = pMs->server->status;
             pMs->pending_status = pMs->server->status;
@@ -2909,7 +2909,7 @@ void MonitorInstanceSimple::tick()
             }
 #endif
 
-            if (SERVER_IS_DOWN(pMs->server))
+            if (server_is_down(pMs->server))
             {
                 pMs->mon_err_count += 1;
             }

server/core/server.cc

@@ -537,7 +537,7 @@ static void cleanup_persistent_connections(const SERVER* server)
 void
 dprintServer(DCB *dcb, const SERVER *server)
 {
-    if (!SERVER_IS_ACTIVE(server))
+    if (!server_is_active(server))
     {
         return;
     }
@@ -556,7 +556,7 @@ dprintServer(DCB *dcb, const SERVER *server)
                mon_get_event_name((mxs_monitor_event_t)server->last_event));
     time_t t = maxscale_started() + MXS_CLOCK_TO_SEC(server->triggered_at);
     dcb_printf(dcb, "\tTriggered at:                        %s\n", http_to_date(t).c_str());
-    if (SERVER_IS_SLAVE(server) || SERVER_IS_RELAY_SERVER(server))
+    if (server_is_slave(server) || server_is_relay(server))
     {
         if (server->rlag >= 0)
         {
@@ -765,7 +765,7 @@ server_set_status_nolock(SERVER *server, uint64_t bit)
     server->status |= bit;
 
     /** clear error logged flag before the next failure */
-    if (SERVER_IS_MASTER(server))
+    if (server_is_master(server))
     {
         server->master_err_is_logged = false;
     }
@@ -1049,7 +1049,7 @@ serverRowCallback(RESULTSET *set, void *data)
         return NULL;
     }
     (*rowno)++;
-    if (SERVER_IS_ACTIVE(server))
+    if (server_is_active(server))
     {
         row = resultset_make_row(set);
         resultset_row_set(row, 0, server->name);
@@ -1599,7 +1599,7 @@ json_t* server_list_to_json(const char* host)
 
     for (SERVER* server = allServers; server; server = server->next)
     {
-        if (SERVER_IS_ACTIVE(server))
+        if (server_is_active(server))
         {
             json_array_append_new(data, server_to_json_data(server, host));
         }

server/modules/authenticator/GSSAPI/GSSAPIAuth/gssapi_auth.cc

@@ -609,7 +609,7 @@ int gssapi_auth_load_users(SERV_LISTENER *listener)
 
         for (SERVER_REF *servers = listener->service->dbref; servers; servers = servers->next)
         {
-            if (!SERVER_REF_IS_ACTIVE(servers) || !SERVER_IS_ACTIVE(servers->server))
+            if (!SERVER_REF_IS_ACTIVE(servers) || !server_is_active(servers->server))
             {
                 continue;
             }

server/modules/authenticator/MySQLAuth/dbusers.cc

@@ -946,7 +946,7 @@ static int get_users(SERV_LISTENER *listener, bool skip_local)
 
     for (server = service->dbref; !service->svc_do_shutdown && server; server = server->next)
     {
-        if (!SERVER_REF_IS_ACTIVE(server) || !SERVER_IS_ACTIVE(server->server) ||
+        if (!SERVER_REF_IS_ACTIVE(server) || !server_is_active(server->server) ||
             (skip_local && server_is_mxs_service(server->server)))
         {
             continue;

server/modules/monitor/galeramon/galeramon.cc

@@ -382,7 +382,7 @@ MXS_MONITORED_SERVER *GaleraMonitor::get_candidate_master()
     /* set min_id to the lowest value of moitor_servers->server->node_id */
     while (moitor_servers)
     {
-        if (!SERVER_IN_MAINT(moitor_servers->server) &&
+        if (!server_is_in_maint(moitor_servers->server) &&
             (moitor_servers->pending_status & SERVER_JOINED))
         {
 
@@ -463,7 +463,7 @@ static MXS_MONITORED_SERVER *set_cluster_master(MXS_MONITORED_SERVER *current_ma
          *
          */
         if ((current_master->pending_status & SERVER_JOINED) &&
-            (!SERVER_IN_MAINT(current_master->server)))
+            (!server_is_in_maint(current_master->server)))
         {
             return current_master;
         }

server/modules/monitor/mariadbmon/cluster_manipulation.cc

@@ -726,7 +726,7 @@ bool MariaDBMonitor::switchover_demote_master(MariaDBServer* current_master, jso
     MYSQL* conn = current_master->m_server_base->con;
     const char* query = ""; // The next query to execute. Used also for error printing.
     // The presence of an external master changes several things.
-    const bool external_master = SERVER_IS_SLAVE_OF_EXT_MASTER(current_master->m_server_base->server);
+    const bool external_master = server_is_slave_of_ext_master(current_master->m_server_base->server);
 
     if (external_master)
     {
@@ -1178,8 +1178,8 @@ bool MariaDBMonitor::is_candidate_better(const MariaDBServer* current_best, cons
             // If both have log_slave_updates on ...
             else if (cand_updates && curr_updates)
             {
-                bool cand_disk_ok = !SERVER_IS_DISK_SPACE_EXHAUSTED(candidate->m_server_base->server);
+                bool cand_disk_ok = !server_is_disk_space_exhausted(candidate->m_server_base->server);
-                bool curr_disk_ok = !SERVER_IS_DISK_SPACE_EXHAUSTED(current_best->m_server_base->server);
+                bool curr_disk_ok = !server_is_disk_space_exhausted(current_best->m_server_base->server);
                 // ... prefer a slave without disk space issues.
                 if (cand_disk_ok && !curr_disk_ok)
                 {
@@ -1215,7 +1215,7 @@ bool MariaDBMonitor::switchover_check_current(const MXS_MONITORED_SERVER* sugges
          mon_serv != NULL && extra_master == NULL;
          mon_serv = mon_serv->next)
     {
-        if (SRV_MASTER_STATUS(mon_serv->pending_status))
+        if (srv_master_status(mon_serv->pending_status))
         {
             if (mon_serv == suggested_curr_master)
             {

server/modules/monitor/mariadbmon/mariadbmon.cc

@@ -606,7 +606,7 @@ void MariaDBMonitor::update_gtid_domain()
 
 void MariaDBMonitor::update_external_master()
 {
-    if (SERVER_IS_SLAVE_OF_EXT_MASTER(m_master->m_server_base->server))
+    if (server_is_slave_of_ext_master(m_master->m_server_base->server))
     {
         ss_dassert(!m_master->m_slave_status.empty());
         if (m_master->m_slave_status[0].master_host != m_external_master_host ||

server/modules/monitor/mariadbmon/mariadbserver.cc

@@ -436,7 +436,7 @@ bool MariaDBServer::wait_until_gtid(const GtidList& target, int timeout, json_t*
 bool MariaDBServer::is_master() const
 {
     // Similar to macro SERVER_IS_MASTER
-    return SRV_MASTER_STATUS(m_server_base->pending_status);
+    return srv_master_status(m_server_base->pending_status);
 }
 
 bool MariaDBServer::is_slave() const

server/modules/monitor/mmmon/mmmon.cc

@@ -321,7 +321,7 @@ void MMMonitor::post_tick()
 
     for(MXS_MONITORED_SERVER *ptr = m_monitor->monitored_servers; ptr; ptr = ptr->next)
     {
-        if (!SERVER_IN_MAINT(ptr->server))
+        if (!server_is_in_maint(ptr->server))
         {
             /* If "detect_stale_master" option is On, let's use the previus master */
             if (m_detectStaleMaster && root_master &&
@@ -369,7 +369,7 @@ MXS_MONITORED_SERVER *MMMonitor::get_current_master()
          * that means SERVER_IS_RUNNING returns 0
          * Let's check only for SERVER_IS_DOWN: server is not running
          */
-        if (SERVER_IS_DOWN(ptr->server))
+        if (server_is_down(ptr->server))
         {
             ptr = ptr->next;
             continue;
@@ -391,7 +391,7 @@ MXS_MONITORED_SERVER *MMMonitor::get_current_master()
     if (m_master != NULL)
     {
         /* If the root master is in MAINT, return NULL */
-        if (SERVER_IN_MAINT(m_master->server))
+        if (server_is_in_maint(m_master->server))
         {
             return NULL;
         }

server/modules/routing/hintrouter/hintrouter.cc

@@ -84,7 +84,7 @@ HintRouterSession* HintRouter::newSession(MXS_SESSION *pSession)
     {
         if (SERVER_REF_IS_ACTIVE(pSref))
         {
-            if (SERVER_IS_MASTER(pSref->server))
+            if (server_is_master(pSref->server))
             {
                 if (!master_ref)
                 {
@@ -95,7 +95,7 @@ HintRouterSession* HintRouter::newSession(MXS_SESSION *pSession)
                     MXS_WARNING("Found multiple master servers when creating session.\n");
                 }
             }
-            else if (SERVER_IS_SLAVE(pSref->server))
+            else if (server_is_slave(pSref->server))
             {
                 slave_refs.push_back(pSref);
             }

server/modules/routing/hintrouter/hintroutersession.cc

@@ -203,7 +203,7 @@ bool HintRouterSession::route_by_hint(GWBUF* pPacket, HINT* hint, bool print_err
         {
             bool master_ok = false;
             // The master server should be already known, but may have changed
-            if (m_master.get() && SERVER_IS_MASTER(m_master.server()))
+            if (m_master.get() && server_is_master(m_master.server()))
             {
                 master_ok = true;
             }
@@ -315,7 +315,7 @@ bool HintRouterSession::route_to_slave(GWBUF* pPacket, bool print_errors)
         for (size_type curr = begin; curr != limit; curr++)
         {
             Dcb& candidate = m_slaves.at(curr % size);
-            if (SERVER_IS_SLAVE(candidate.server()))
+            if (server_is_slave(candidate.server()))
             {
                 HR_DEBUG("Writing packet to slave: '%s'.", candidate.server()->name);
                 success = candidate.write(pPacket);
@@ -390,7 +390,7 @@ void HintRouterSession::update_connections()
          iter != m_backends.end(); iter++)
     {
         SERVER* server = iter->second.get()->server;
-        if (SERVER_IS_MASTER(server))
+        if (server_is_master(server))
         {
             if (!m_master.get())
             {
@@ -401,7 +401,7 @@ void HintRouterSession::update_connections()
                 MXS_WARNING("Found multiple master servers when updating connections.");
             }
         }
-        else if (SERVER_IS_SLAVE(server))
+        else if (server_is_slave(server))
         {
             m_slaves.push_back(iter->second);
         }

server/modules/routing/readconnroute/readconnroute.cc

@@ -314,13 +314,13 @@ newSession(MXS_ROUTER *instance, MXS_SESSION *session)
      */
     for (SERVER_REF *ref = inst->service->dbref; ref; ref = ref->next)
     {
-        if (!SERVER_REF_IS_ACTIVE(ref) || SERVER_IN_MAINT(ref->server))
+        if (!SERVER_REF_IS_ACTIVE(ref) || server_is_in_maint(ref->server))
         {
             continue;
         }
 
         /* Check server status bits against bitvalue from router_options */
-        if (ref && SERVER_IS_RUNNING(ref->server) &&
+        if (ref && server_is_running(ref->server) &&
             (ref->server->status & client_rses->bitmask & client_rses->bitvalue))
         {
             if (master_host)
@@ -511,11 +511,11 @@ static void log_closed_session(mxs_mysql_cmd_t mysql_command, bool is_closed,
     {
         sprintf(msg, "Session is closed.");
     }
-    else if (SERVER_IS_DOWN(ref->server))
+    else if (server_is_down(ref->server))
     {
         sprintf(msg, "Server '%s' is down.", ref->server->name);
     }
-    else if (SERVER_IN_MAINT(ref->server))
+    else if (server_is_in_maint(ref->server))
     {
         sprintf(msg, "Server '%s' is in maintenance.", ref->server->name);
     }
@@ -545,7 +545,7 @@ static inline bool connection_is_valid(ROUTER_INSTANCE* inst, ROUTER_CLIENT_SES*
     // 'router_options=slave' in the configuration file and there was only
     // the sole master available at session creation time.
 
-    if (SERVER_IS_RUNNING(router_cli_ses->backend->server) &&
+    if (server_is_running(router_cli_ses->backend->server) &&
         (router_cli_ses->backend->server->status & router_cli_ses->bitmask & router_cli_ses->bitvalue))
     {
         // Note the use of '==' and not '|'. We must use the former to exclude a
@@ -855,7 +855,7 @@ static SERVER_REF *get_root_master(SERVER_REF *servers)
     SERVER_REF *master_host = NULL;
     for (SERVER_REF *ref = servers; ref; ref = ref->next)
     {
-        if (ref->active && SERVER_IS_MASTER(ref->server))
+        if (ref->active && server_is_master(ref->server))
         {
             // No master found yet or this one has higher weight.
             if (master_host == NULL || ref->weight > master_host->weight)

server/modules/routing/readwritesplit/readwritesplit.hh

@@ -127,8 +127,8 @@ static const MXS_ENUM_VALUE master_failure_mode_values[] =
         strncmp(s,"LEAST_CURRENT_OPERATIONS", strlen("LEAST_CURRENT_OPERATIONS")) == 0 ?        \
         LEAST_CURRENT_OPERATIONS : UNDEFINED_CRITERIA))))
 
-#define BACKEND_TYPE(b) (SERVER_IS_MASTER((b)->backend_server) ? BE_MASTER :    \
+#define BACKEND_TYPE(b) (server_is_master((b)->backend_server) ? BE_MASTER :    \
-        (SERVER_IS_SLAVE((b)->backend_server) ? BE_SLAVE :  BE_UNDEFINED));
+        (server_is_slave((b)->backend_server) ? BE_SLAVE :  BE_UNDEFINED));
 
 #define MARIADB_WAIT_GTID_FUNC "MASTER_GTID_WAIT"
 #define MYSQL_WAIT_GTID_FUNC   "WAIT_FOR_EXECUTED_GTID_SET"

server/modules/routing/schemarouter/schemarouterinstance.cc

@@ -130,7 +130,7 @@ bool connect_backend_servers(SSRBackendList& backends, MXS_SESSION* session)
     {
         SERVER_REF* b = (*it)->backend();
 
-        if (SERVER_IS_RUNNING(b->server))
+        if (server_is_running(b->server))
         {
             servers_found += 1;
 

server/modules/routing/schemarouter/schemaroutersession.cc

@@ -209,7 +209,7 @@ SERVER* SchemaRouterSession::resolve_query_target(GWBUF* pPacket,
         /** We either don't know or don't care where this query should go */
         target = get_shard_target(pPacket, type);
 
-        if (target && SERVER_IS_RUNNING(target))
+        if (target && server_is_running(target))
         {
             route_target = TARGET_NAMED_SERVER;
         }
@@ -236,7 +236,7 @@ SERVER* SchemaRouterSession::resolve_query_target(GWBUF* pPacket,
         for (SSRBackendList::iterator it = m_backends.begin(); it != m_backends.end(); it++)
         {
             SERVER *server = (*it)->backend()->server;
-            if (SERVER_IS_RUNNING(server))
+            if (server_is_running(server))
             {
                 route_target = TARGET_NAMED_SERVER;
                 target = server;
@@ -739,7 +739,7 @@ bool SchemaRouterSession::route_session_write(GWBUF* querybuf, uint8_t command)
             if (MXS_LOG_PRIORITY_IS_ENABLED(LOG_INFO))
             {
                 MXS_INFO("Route query to %s\t%s:%d",
-                         SERVER_IS_MASTER((*it)->backend()->server) ? "master" : "slave",
+                         server_is_master((*it)->backend()->server) ? "master" : "slave",
                          (*it)->backend()->server->address,
                          (*it)->backend()->server->port);
             }
@@ -1382,7 +1382,7 @@ void SchemaRouterSession::query_databases()
     for (SSRBackendList::iterator it = m_backends.begin(); it != m_backends.end(); it++)
     {
         if ((*it)->in_use() && !(*it)->is_closed() &
-            SERVER_IS_RUNNING((*it)->backend()->server))
+            server_is_running((*it)->backend()->server))
         {
             GWBUF* clone = gwbuf_clone(buffer);
             MXS_ABORT_IF_NULL(clone);
@@ -1524,7 +1524,7 @@ bool SchemaRouterSession::get_shard_dcb(DCB** p_dcb, char* name)
          */
         if ((*it)->in_use() &&
             (strncasecmp(name, b->server->name, PATH_MAX) == 0) &&
-            SERVER_IS_RUNNING(b->server))
+            server_is_running(b->server))
         {
             *p_dcb = (*it)->dcb();
             succp = true;