hcq/MaxScale
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
Show Stats 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;
/** 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
* 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 */
router->rwsplit_config.rw_retry_failed_reads = true;
router->rwsplit_config.retry_failed_reads = true;
/** Call this before refreshInstance */
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 */
if (router->rwsplit_config.rw_disable_sescmd_hist &&
router->rwsplit_config.rw_max_sescmd_history_size > 0)
if (router->rwsplit_config.disable_sescmd_history &&
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
* 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.
@ -223,7 +223,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
* Read default value for slave replication lag upper limit and then
* 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");
if (param != NULL)
@ -232,7 +232,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
}
router->rwsplit_version = service->svc_config_version;
/** 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");
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 */
if (!select_connect_backend_servers(&master_ref, backend_ref, router_nservers,
max_nslaves, max_slave_rlag,
client_rses->rses_config.rw_slave_select_criteria,
client_rses->rses_config.slave_selection_criteria,
session, router, false))
{
/**
@ -331,7 +331,7 @@ static void *newSession(ROUTER *router_inst, SESSION *session)
int n_conn = 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);
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;
@ -676,14 +676,14 @@ static void clientReply(ROUTER *instance, void *router_session, GWBUF *writebuf,
bool rconn = false;
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(
&router_cli_ses->rses_master_ref, router_cli_ses->rses_backend_ref,
router_cli_ses->rses_nbackends,
router_cli_ses->rses_config.rw_max_slave_conn_count,
router_cli_ses->rses_config.rw_max_slave_replication_lag,
router_cli_ses->rses_config.rw_slave_select_criteria,
router_cli_ses->rses_config.max_slave_connections,
router_cli_ses->rses_config.max_slave_replication_lag,
router_cli_ses->rses_config.slave_selection_criteria,
router_cli_ses->rses_master_ref->bref_dcb->session,
router_cli_ses->router,
true);
@ -1010,9 +1010,9 @@ int rses_get_max_slavecount(ROUTER_CLIENT_SES *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
{
@ -1036,9 +1036,9 @@ int rses_get_max_replication_lag(ROUTER_CLIENT_SES *rses)
CHK_CLIENT_RSES(rses);
/** 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
{
@ -1197,47 +1197,47 @@ static bool rwsplit_process_router_options(ROUTER_INSTANCE *router,
"Allowed values are LEAST_GLOBAL_CONNECTIONS, "
"LEAST_ROUTER_CONNECTIONS, LEAST_BEHIND_MASTER,"
"and LEAST_CURRENT_OPERATIONS.",
STRCRITERIA(router->rwsplit_config.rw_slave_select_criteria));
STRCRITERIA(router->rwsplit_config.slave_selection_criteria));
success = false;
}
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
router->rwsplit_config.rw_master_failure_mode = RW_ERROR_ON_WRITE;
router->rwsplit_config.master_failure_mode = RW_ERROR_ON_WRITE;
}
else
{
@ -1342,7 +1342,7 @@ static void handleError(ROUTER *instance, void *router_session,
SERVER *srv = rses->rses_master_ref->ref->server;
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)))
{
/** 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
* 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;
}
@ -1607,7 +1607,7 @@ static bool handle_error_new_connection(ROUTER_INSTANCE *inst,
myrses->rses_backend_ref,
myrses->rses_nbackends,
max_nslaves, max_slave_rlag,
myrses->rses_config.rw_slave_select_criteria,
myrses->rses_config.slave_selection_criteria,
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 */
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) /
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 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 "
"too few backend servers configured in "
"MaxScale.cnf. Found %d when %d is required.",
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)
{
@ -1723,7 +1723,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
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",
@ -1736,7 +1736,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
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;
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);
@ -1768,7 +1768,7 @@ static void refreshInstance(ROUTER_INSTANCE *router,
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
* to use for each connection*/
int rw_max_slave_conn_count; /**< Maximum number of slaves for each connection*/
select_criteria_t rw_slave_select_criteria; /**< The slave selection criteria */
int rw_max_slave_replication_lag; /**< Maximum replication lag */
target_t rw_use_sql_variables_in; /**< Whether to send user variables
int max_slave_connections; /**< Maximum number of slaves for each connection*/
select_criteria_t slave_selection_criteria; /**< The slave selection criteria */
int max_slave_replication_lag; /**< Maximum replication lag */
target_t use_sql_variables_in; /**< Whether to send user variables
* to master or all nodes */
int rw_max_sescmd_history_size; /**< Maximum amount of session commands to store */
bool rw_disable_sescmd_hist; /**< Disable session command history */
bool rw_master_reads; /**< Use master for reads */
bool rw_strict_multi_stmt; /**< Force non-multistatement queries to be routed
int max_sescmd_history; /**< Maximum amount of session commands to store */
bool disable_sescmd_history; /**< Disable session command history */
bool master_accept_reads; /**< Use master for reads */
bool strict_multi_stmt; /**< Force non-multistatement queries to be routed
* 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 */
bool rw_retry_failed_reads; /**< Retry failed reads on other servers */
bool retry_failed_reads; /**< Retry failed reads on other servers */
} rwsplit_config_t;
#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))
{
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))
{
@ -251,19 +251,19 @@ bool route_session_write(ROUTER_CLIENT_SES *router_cli_ses,
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_config.rw_max_sescmd_history_size)
router_cli_ses->rses_config.max_sescmd_history)
{
MXS_WARNING("Router session exceeded session command history limit. "
"Slave recovery is disabled and only slave servers with "
"consistent session state are used "
"for the duration of the session.");
router_cli_ses->rses_config.rw_disable_sescmd_hist = true;
router_cli_ses->rses_config.rw_max_sescmd_history_size = 0;
router_cli_ses->rses_config.disable_sescmd_history = true;
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;
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 ||
(b->server->rlag != MAX_RLAG_NOT_AVAILABLE &&
b->server->rlag <= max_rlag)) &&
!rses->rses_config.rw_master_reads)
!rses->rses_config.master_accept_reads)
{
/** found slave */
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))
{
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;
}
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 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;
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)
{
target = TARGET_MASTER;
@ -1121,7 +1121,7 @@ static void log_master_routing_failure(ROUTER_CLIENT_SES *rses, bool found,
else
{
/** 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 "
"when no master was available");
@ -1172,7 +1172,7 @@ bool handle_master_is_target(ROUTER_INSTANCE *inst, ROUTER_CLIENT_SES *rses,
else
{
/** 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);
@ -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))
{
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 *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)))
{
MXS_ERROR("Couldn't find suitable Master from %d candidates.", router_nservers);