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

Name variables the same way as the parameters

Browse Source 
The variables now use the actual option and parameter names. This should
help make the code more readable and easier to understand in relation to
the used options.
This commit is contained in:
Markus Mäkelä
2017-01-05 11:03:51 +02:00
parent 410ba7726e
commit 1c8a4b13b9
4 changed files with 65 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
server/modules/routing/readwritesplit/readwritesplit.c
View File

@ -175,14 +175,14 @@ static ROUTER *createInstance(SERVICE *service, char **options)
router->available_slaves = true; router->available_slaves = true;
/** Enable strict multistatement handling by default */ /** Enable strict multistatement handling by default */
router->rwsplit_config.rw_strict_multi_stmt = true; router->rwsplit_config.strict_multi_stmt = true;
/** By default, the client connection is closed immediately when a master /** By default, the client connection is closed immediately when a master
* failure is detected */ * failure is detected */
router->rwsplit_config.rw_master_failure_mode = RW_FAIL_INSTANTLY; router->rwsplit_config.master_failure_mode = RW_FAIL_INSTANTLY;
/** Try to retry failed reads */ /** Try to retry failed reads */
router->rwsplit_config.rw_retry_failed_reads = true; router->rwsplit_config.retry_failed_reads = true;
/** Call this before refreshInstance */ /** Call this before refreshInstance */
if (options && !rwsplit_process_router_options(router, options)) if (options && !rwsplit_process_router_options(router, options))
@ -192,10 +192,10 @@ static ROUTER *createInstance(SERVICE *service, char **options)
} }
/** These options cancel each other out */ /** These options cancel each other out */
if (router->rwsplit_config.rw_disable_sescmd_hist && if (router->rwsplit_config.disable_sescmd_history &&
router->rwsplit_config.rw_max_sescmd_history_size > 0) router->rwsplit_config.max_sescmd_history > 0)
{ {
router->rwsplit_config.rw_max_sescmd_history_size = 0; router->rwsplit_config.max_sescmd_history = 0;
} }
/** /**
@ -203,11 +203,11 @@ static ROUTER *createInstance(SERVICE *service, char **options)
* LEAST_CURRENT_OPERATIONS allows us to balance evenly across all the * LEAST_CURRENT_OPERATIONS allows us to balance evenly across all the
* configured slaves. * configured slaves.
*/ */
router->rwsplit_config.rw_max_slave_conn_count = MAX_SLAVE_COUNT; router->rwsplit_config.max_slave_connections = MAX_SLAVE_COUNT;
if (router->rwsplit_config.rw_slave_select_criteria == UNDEFINED_CRITERIA) if (router->rwsplit_config.slave_selection_criteria == UNDEFINED_CRITERIA)
{ {
router->rwsplit_config.rw_slave_select_criteria = DEFAULT_CRITERIA; router->rwsplit_config.slave_selection_criteria = DEFAULT_CRITERIA;
} }
/** /**
* Copy all config parameters from service to router instance. * Copy all config parameters from service to router instance.
@ -223,7 +223,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
* Read default value for slave replication lag upper limit and then * Read default value for slave replication lag upper limit and then
* configured value if it exists. * configured value if it exists.
*/ */
router->rwsplit_config.rw_max_slave_replication_lag = CONFIG_MAX_SLAVE_RLAG; router->rwsplit_config.max_slave_replication_lag = CONFIG_MAX_SLAVE_RLAG;
param = config_get_param(service->svc_config_param, "max_slave_replication_lag"); param = config_get_param(service->svc_config_param, "max_slave_replication_lag");
if (param != NULL) if (param != NULL)
@ -232,7 +232,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
} }
router->rwsplit_version = service->svc_config_version; router->rwsplit_version = service->svc_config_version;
/** Set default values */ /** Set default values */
router->rwsplit_config.rw_use_sql_variables_in = CONFIG_SQL_VARIABLES_IN; router->rwsplit_config.use_sql_variables_in = CONFIG_SQL_VARIABLES_IN;
param = config_get_param(service->svc_config_param, "use_sql_variables_in"); param = config_get_param(service->svc_config_param, "use_sql_variables_in");
if (param != NULL) if (param != NULL)
@ -310,7 +310,7 @@ static void *newSession(ROUTER *router_inst, SESSION *session)
backend_ref_t *master_ref = NULL; /*< pointer to selected master */ backend_ref_t *master_ref = NULL; /*< pointer to selected master */
if (!select_connect_backend_servers(&master_ref, backend_ref, router_nservers, if (!select_connect_backend_servers(&master_ref, backend_ref, router_nservers,
max_nslaves, max_slave_rlag, max_nslaves, max_slave_rlag,
client_rses->rses_config.rw_slave_select_criteria, client_rses->rses_config.slave_selection_criteria,
session, router, false)) session, router, false))
{ {
/** /**
@ -331,7 +331,7 @@ static void *newSession(ROUTER *router_inst, SESSION *session)
int n_conn = 0; int n_conn = 0;
double pct = (double)client_rses->rses_config.rw_max_slave_conn_percent / 100.0; double pct = (double)client_rses->rses_config.rw_max_slave_conn_percent / 100.0;
n_conn = MXS_MAX(floor((double)client_rses->rses_nbackends * pct), 1); n_conn = MXS_MAX(floor((double)client_rses->rses_nbackends * pct), 1);
client_rses->rses_config.rw_max_slave_conn_count = n_conn; client_rses->rses_config.max_slave_connections = n_conn;
} }
router->stats.n_sessions += 1; router->stats.n_sessions += 1;
@ -676,14 +676,14 @@ static void clientReply(ROUTER *instance, void *router_session, GWBUF *writebuf,
bool rconn = false; bool rconn = false;
writebuf = sescmd_cursor_process_replies(writebuf, bref, &rconn); writebuf = sescmd_cursor_process_replies(writebuf, bref, &rconn);
if (rconn && !router_inst->rwsplit_config.rw_disable_sescmd_hist) if (rconn && !router_inst->rwsplit_config.disable_sescmd_history)
{ {
select_connect_backend_servers( select_connect_backend_servers(
&router_cli_ses->rses_master_ref, router_cli_ses->rses_backend_ref, &router_cli_ses->rses_master_ref, router_cli_ses->rses_backend_ref,
router_cli_ses->rses_nbackends, router_cli_ses->rses_nbackends,
router_cli_ses->rses_config.rw_max_slave_conn_count, router_cli_ses->rses_config.max_slave_connections,
router_cli_ses->rses_config.rw_max_slave_replication_lag, router_cli_ses->rses_config.max_slave_replication_lag,
router_cli_ses->rses_config.rw_slave_select_criteria, router_cli_ses->rses_config.slave_selection_criteria,
router_cli_ses->rses_master_ref->bref_dcb->session, router_cli_ses->rses_master_ref->bref_dcb->session,
router_cli_ses->router, router_cli_ses->router,
true); true);
@ -1010,9 +1010,9 @@ int rses_get_max_slavecount(ROUTER_CLIENT_SES *rses,
CHK_CLIENT_RSES(rses); CHK_CLIENT_RSES(rses);
if (rses->rses_config.rw_max_slave_conn_count > 0) if (rses->rses_config.max_slave_connections > 0)
{ {
conf_max_nslaves = rses->rses_config.rw_max_slave_conn_count; conf_max_nslaves = rses->rses_config.max_slave_connections;
} }
else else
{ {
@ -1036,9 +1036,9 @@ int rses_get_max_replication_lag(ROUTER_CLIENT_SES *rses)
CHK_CLIENT_RSES(rses); CHK_CLIENT_RSES(rses);
/** if there is no configured value, then longest possible int is used */ /** if there is no configured value, then longest possible int is used */
if (rses->rses_config.rw_max_slave_replication_lag > 0) if (rses->rses_config.max_slave_replication_lag > 0)
{ {
conf_max_rlag = rses->rses_config.rw_max_slave_replication_lag; conf_max_rlag = rses->rses_config.max_slave_replication_lag;
} }
else else
{ {
@ -1197,47 +1197,47 @@ static bool rwsplit_process_router_options(ROUTER_INSTANCE *router,
"Allowed values are LEAST_GLOBAL_CONNECTIONS, " "Allowed values are LEAST_GLOBAL_CONNECTIONS, "
"LEAST_ROUTER_CONNECTIONS, LEAST_BEHIND_MASTER," "LEAST_ROUTER_CONNECTIONS, LEAST_BEHIND_MASTER,"
"and LEAST_CURRENT_OPERATIONS.", "and LEAST_CURRENT_OPERATIONS.",
STRCRITERIA(router->rwsplit_config.rw_slave_select_criteria)); STRCRITERIA(router->rwsplit_config.slave_selection_criteria));
success = false; success = false;
} }
else else
{ {
router->rwsplit_config.rw_slave_select_criteria = c; router->rwsplit_config.slave_selection_criteria = c;
} }
} }
else if (strcmp(options[i], "max_sescmd_history") == 0) else if (strcmp(options[i], "max_sescmd_history") == 0)
{ {
router->rwsplit_config.rw_max_sescmd_history_size = atoi(value); router->rwsplit_config.max_sescmd_history = atoi(value);
} }
else if (strcmp(options[i], "disable_sescmd_history") == 0) else if (strcmp(options[i], "disable_sescmd_history") == 0)
{ {
router->rwsplit_config.rw_disable_sescmd_hist = config_truth_value(value); router->rwsplit_config.disable_sescmd_history = config_truth_value(value);
} }
else if (strcmp(options[i], "master_accept_reads") == 0) else if (strcmp(options[i], "master_accept_reads") == 0)
{ {
router->rwsplit_config.rw_master_reads = config_truth_value(value); router->rwsplit_config.master_accept_reads = config_truth_value(value);
} }
else if (strcmp(options[i], "strict_multi_stmt") == 0) else if (strcmp(options[i], "strict_multi_stmt") == 0)
{ {
router->rwsplit_config.rw_strict_multi_stmt = config_truth_value(value); router->rwsplit_config.strict_multi_stmt = config_truth_value(value);
} }
else if (strcmp(options[i], "retry_failed_reads") == 0) else if (strcmp(options[i], "retry_failed_reads") == 0)
{ {
router->rwsplit_config.rw_retry_failed_reads = config_truth_value(value); router->rwsplit_config.retry_failed_reads = config_truth_value(value);
} }
else if (strcmp(options[i], "master_failure_mode") == 0) else if (strcmp(options[i], "master_failure_mode") == 0)
{ {
if (strcasecmp(value, "fail_instantly") == 0) if (strcasecmp(value, "fail_instantly") == 0)
{ {
router->rwsplit_config.rw_master_failure_mode = RW_FAIL_INSTANTLY; router->rwsplit_config.master_failure_mode = RW_FAIL_INSTANTLY;
} }
else if (strcasecmp(value, "fail_on_write") == 0) else if (strcasecmp(value, "fail_on_write") == 0)
{ {
router->rwsplit_config.rw_master_failure_mode = RW_FAIL_ON_WRITE; router->rwsplit_config.master_failure_mode = RW_FAIL_ON_WRITE;
} }
else if (strcasecmp(value, "error_on_write") == 0) else if (strcasecmp(value, "error_on_write") == 0)
{ {
router->rwsplit_config.rw_master_failure_mode = RW_ERROR_ON_WRITE; router->rwsplit_config.master_failure_mode = RW_ERROR_ON_WRITE;
} }
else else
{ {
@ -1342,7 +1342,7 @@ static void handleError(ROUTER *instance, void *router_session,
SERVER *srv = rses->rses_master_ref->ref->server; SERVER *srv = rses->rses_master_ref->ref->server;
bool can_continue = false; bool can_continue = false;
if (rses->rses_config.rw_master_failure_mode != RW_FAIL_INSTANTLY && if (rses->rses_config.master_failure_mode != RW_FAIL_INSTANTLY &&
(bref == NULL || !BREF_IS_WAITING_RESULT(bref))) (bref == NULL || !BREF_IS_WAITING_RESULT(bref)))
{ {
/** The failure of a master is not considered a critical /** The failure of a master is not considered a critical
@ -1597,7 +1597,7 @@ static bool handle_error_new_connection(ROUTER_INSTANCE *inst,
* Try to get replacement slave or at least the minimum * Try to get replacement slave or at least the minimum
* number of slave connections for router session. * number of slave connections for router session.
*/ */
if (inst->rwsplit_config.rw_disable_sescmd_hist) if (inst->rwsplit_config.disable_sescmd_history)
{ {
succp = have_enough_servers(myrses, 1, myrses->rses_nbackends, inst) ? true : false; succp = have_enough_servers(myrses, 1, myrses->rses_nbackends, inst) ? true : false;
} }
@ -1607,7 +1607,7 @@ static bool handle_error_new_connection(ROUTER_INSTANCE *inst,
myrses->rses_backend_ref, myrses->rses_backend_ref,
myrses->rses_nbackends, myrses->rses_nbackends,
max_nslaves, max_slave_rlag, max_nslaves, max_slave_rlag,
myrses->rses_config.rw_slave_select_criteria, myrses->rses_config.slave_selection_criteria,
ses, inst, true); ses, inst, true);
} }
@ -1631,7 +1631,7 @@ static bool have_enough_servers(ROUTER_CLIENT_SES *rses, const int min_nsrv,
/** With too few servers session is not created */ /** With too few servers session is not created */
if (router_nsrv < min_nsrv || if (router_nsrv < min_nsrv ||
MXS_MAX((rses)->rses_config.rw_max_slave_conn_count, MXS_MAX((rses)->rses_config.max_slave_connections,
(router_nsrv * (rses)->rses_config.rw_max_slave_conn_percent) / (router_nsrv * (rses)->rses_config.rw_max_slave_conn_percent) /
100) < min_nsrv) 100) < min_nsrv)
{ {
@ -1647,13 +1647,13 @@ static bool have_enough_servers(ROUTER_CLIENT_SES *rses, const int min_nsrv,
int pct = (rses)->rses_config.rw_max_slave_conn_percent / 100; int pct = (rses)->rses_config.rw_max_slave_conn_percent / 100;
int nservers = router_nsrv * pct; int nservers = router_nsrv * pct;
if ((rses)->rses_config.rw_max_slave_conn_count < min_nsrv) if ((rses)->rses_config.max_slave_connections < min_nsrv)
{ {
MXS_ERROR("Unable to start %s service. There are " MXS_ERROR("Unable to start %s service. There are "
"too few backend servers configured in " "too few backend servers configured in "
"MaxScale.cnf. Found %d when %d is required.", "MaxScale.cnf. Found %d when %d is required.",
router->service->name, router->service->name,
(rses)->rses_config.rw_max_slave_conn_count, min_nsrv); (rses)->rses_config.max_slave_connections, min_nsrv);
} }
if (nservers < min_nsrv) if (nservers < min_nsrv)
{ {
@ -1723,7 +1723,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
if (succp) if (succp)
{ {
router->rwsplit_config.rw_max_slave_conn_count = val; router->rwsplit_config.max_slave_connections = val;
} }
} }
else if (strncmp(param->name, "max_slave_replication_lag", else if (strncmp(param->name, "max_slave_replication_lag",
@ -1736,7 +1736,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
if (succp) if (succp)
{ {
router->rwsplit_config.rw_max_slave_replication_lag = val; router->rwsplit_config.max_slave_replication_lag = val;
} }
} }
} }
@ -1747,7 +1747,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
int val; int val;
bool succp; bool succp;
router->rwsplit_config.rw_max_slave_conn_count = 0; router->rwsplit_config.max_slave_connections = 0;
succp = config_get_valint(&val, param, NULL, paramtype); succp = config_get_valint(&val, param, NULL, paramtype);
@ -1768,7 +1768,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
if (succp) if (succp)
{ {
router->rwsplit_config.rw_use_sql_variables_in = valtarget; router->rwsplit_config.use_sql_variables_in = valtarget;
} }
} }
} }

20
server/modules/routing/readwritesplit/readwritesplit.h
View File

@ -217,19 +217,19 @@ typedef struct rwsplit_config_st
{ {
int rw_max_slave_conn_percent; /**< Maximum percentage of slaves int rw_max_slave_conn_percent; /**< Maximum percentage of slaves
* to use for each connection*/ * to use for each connection*/
int rw_max_slave_conn_count; /**< Maximum number of slaves for each connection*/ int max_slave_connections; /**< Maximum number of slaves for each connection*/
select_criteria_t rw_slave_select_criteria; /**< The slave selection criteria */ select_criteria_t slave_selection_criteria; /**< The slave selection criteria */
int rw_max_slave_replication_lag; /**< Maximum replication lag */ int max_slave_replication_lag; /**< Maximum replication lag */
target_t rw_use_sql_variables_in; /**< Whether to send user variables target_t use_sql_variables_in; /**< Whether to send user variables
* to master or all nodes */ * to master or all nodes */
int rw_max_sescmd_history_size; /**< Maximum amount of session commands to store */ int max_sescmd_history; /**< Maximum amount of session commands to store */
bool rw_disable_sescmd_hist; /**< Disable session command history */ bool disable_sescmd_history; /**< Disable session command history */
bool rw_master_reads; /**< Use master for reads */ bool master_accept_reads; /**< Use master for reads */
bool rw_strict_multi_stmt; /**< Force non-multistatement queries to be routed bool strict_multi_stmt; /**< Force non-multistatement queries to be routed
* to the master after a multistatement query. */ * to the master after a multistatement query. */
enum failure_mode rw_master_failure_mode; /**< Master server failure handling mode. enum failure_mode master_failure_mode; /**< Master server failure handling mode.
* @see enum failure_mode */ * @see enum failure_mode */
bool rw_retry_failed_reads; /**< Retry failed reads on other servers */ bool retry_failed_reads; /**< Retry failed reads on other servers */
} rwsplit_config_t; } rwsplit_config_t;
#if defined(PREP_STMT_CACHING) #if defined(PREP_STMT_CACHING)

26
server/modules/routing/readwritesplit/rwsplit_route_stmt.c
View File

@ -131,7 +131,7 @@ bool route_single_stmt(ROUTER_INSTANCE *inst, ROUTER_CLIENT_SES *rses,
else if (TARGET_IS_SLAVE(route_target)) else if (TARGET_IS_SLAVE(route_target))
{ {
succp = handle_slave_is_target(inst, rses, &target_dcb); succp = handle_slave_is_target(inst, rses, &target_dcb);
store_stmt = rses->rses_config.rw_retry_failed_reads; store_stmt = rses->rses_config.retry_failed_reads;
} }
else if (TARGET_IS_MASTER(route_target)) else if (TARGET_IS_MASTER(route_target))
{ {
@ -251,19 +251,19 @@ bool route_session_write(ROUTER_CLIENT_SES *router_cli_ses,
goto return_succp; goto return_succp;
} }
if (router_cli_ses->rses_config.rw_max_sescmd_history_size > 0 && if (router_cli_ses->rses_config.max_sescmd_history > 0 &&
router_cli_ses->rses_nsescmd >= router_cli_ses->rses_nsescmd >=
router_cli_ses->rses_config.rw_max_sescmd_history_size) router_cli_ses->rses_config.max_sescmd_history)
{ {
MXS_WARNING("Router session exceeded session command history limit. " MXS_WARNING("Router session exceeded session command history limit. "
"Slave recovery is disabled and only slave servers with " "Slave recovery is disabled and only slave servers with "
"consistent session state are used " "consistent session state are used "
"for the duration of the session."); "for the duration of the session.");
router_cli_ses->rses_config.rw_disable_sescmd_hist = true; router_cli_ses->rses_config.disable_sescmd_history = true;
router_cli_ses->rses_config.rw_max_sescmd_history_size = 0; router_cli_ses->rses_config.max_sescmd_history = 0;
} }
if (router_cli_ses->rses_config.rw_disable_sescmd_hist) if (router_cli_ses->rses_config.disable_sescmd_history)
{ {
rses_property_t *prop, *tmp; rses_property_t *prop, *tmp;
backend_ref_t *bref; backend_ref_t *bref;
@ -589,7 +589,7 @@ bool rwsplit_get_dcb(DCB **p_dcb, ROUTER_CLIENT_SES *rses, backend_type_t btype,
(max_rlag == MAX_RLAG_UNDEFINED || (max_rlag == MAX_RLAG_UNDEFINED ||
(b->server->rlag != MAX_RLAG_NOT_AVAILABLE && (b->server->rlag != MAX_RLAG_NOT_AVAILABLE &&
b->server->rlag <= max_rlag)) && b->server->rlag <= max_rlag)) &&
!rses->rses_config.rw_master_reads) !rses->rses_config.master_accept_reads)
{ {
/** found slave */ /** found slave */
candidate_bref = &backend_ref[i]; candidate_bref = &backend_ref[i];
@ -608,7 +608,7 @@ bool rwsplit_get_dcb(DCB **p_dcb, ROUTER_CLIENT_SES *rses, backend_type_t btype,
b->server->rlag <= max_rlag)) b->server->rlag <= max_rlag))
{ {
candidate_bref = check_candidate_bref(candidate_bref, &backend_ref[i], candidate_bref = check_candidate_bref(candidate_bref, &backend_ref[i],
rses->rses_config.rw_slave_select_criteria); rses->rses_config.slave_selection_criteria);
candidate.status = candidate_bref->ref->server->status; candidate.status = candidate_bref->ref->server->status;
} }
else else
@ -688,10 +688,10 @@ route_target_t get_route_target(ROUTER_CLIENT_SES *rses,
{ {
bool trx_active = session_trx_is_active(rses->client_dcb->session); bool trx_active = session_trx_is_active(rses->client_dcb->session);
bool load_active = rses->rses_load_active; bool load_active = rses->rses_load_active;
target_t use_sql_variables_in = rses->rses_config.rw_use_sql_variables_in; target_t use_sql_variables_in = rses->rses_config.use_sql_variables_in;
route_target_t target = TARGET_UNDEFINED; route_target_t target = TARGET_UNDEFINED;
if (rses->rses_config.rw_strict_multi_stmt && rses->forced_node && if (rses->rses_config.strict_multi_stmt && rses->forced_node &&
rses->forced_node == rses->rses_master_ref) rses->forced_node == rses->rses_master_ref)
{ {
target = TARGET_MASTER; target = TARGET_MASTER;
@ -1121,7 +1121,7 @@ static void log_master_routing_failure(ROUTER_CLIENT_SES *rses, bool found,
else else
{ {
/** We never had a master connection, the session must be in read-only mode */ /** We never had a master connection, the session must be in read-only mode */
if (rses->rses_config.rw_master_failure_mode != RW_FAIL_INSTANTLY) if (rses->rses_config.master_failure_mode != RW_FAIL_INSTANTLY)
{ {
sprintf(errmsg, "Session is in read-only mode because it was created " sprintf(errmsg, "Session is in read-only mode because it was created "
"when no master was available"); "when no master was available");
@ -1172,7 +1172,7 @@ bool handle_master_is_target(ROUTER_INSTANCE *inst, ROUTER_CLIENT_SES *rses,
else else
{ {
/** The original master is not available, we can't route the write */ /** The original master is not available, we can't route the write */
if (rses->rses_config.rw_master_failure_mode == RW_ERROR_ON_WRITE) if (rses->rses_config.master_failure_mode == RW_ERROR_ON_WRITE)
{ {
succp = send_readonly_error(rses->client_dcb); succp = send_readonly_error(rses->client_dcb);
@ -1409,7 +1409,7 @@ static backend_ref_t *get_root_master_bref(ROUTER_CLIENT_SES *rses)
} }
} }
if (candidate_bref == NULL && rses->rses_config.rw_master_failure_mode == RW_FAIL_INSTANTLY && if (candidate_bref == NULL && rses->rses_config.master_failure_mode == RW_FAIL_INSTANTLY &&
rses->rses_master_ref && BREF_IS_IN_USE(rses->rses_master_ref)) rses->rses_master_ref && BREF_IS_IN_USE(rses->rses_master_ref))
{ {
MXS_ERROR("Could not find master among the backend servers. " MXS_ERROR("Could not find master among the backend servers. "

2
server/modules/routing/readwritesplit/rwsplit_select_backends.c
View File

@ -166,7 +166,7 @@ bool select_connect_backend_servers(backend_ref_t **p_master_ref,
SERVER_REF *master_backend = get_root_master(backend_ref, router_nservers); SERVER_REF *master_backend = get_root_master(backend_ref, router_nservers);
SERVER *master_host = master_backend ? master_backend->server : NULL; SERVER *master_host = master_backend ? master_backend->server : NULL;
if (router->rwsplit_config.rw_master_failure_mode == RW_FAIL_INSTANTLY && if (router->rwsplit_config.master_failure_mode == RW_FAIL_INSTANTLY &&
(master_host == NULL || SERVER_IS_DOWN(master_host))) (master_host == NULL || SERVER_IS_DOWN(master_host)))
{ {
MXS_ERROR("Couldn't find suitable Master from %d candidates.", router_nservers); MXS_ERROR("Couldn't find suitable Master from %d candidates.", router_nservers);