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

Use common constants for monitor and server parameters

Browse Source 
The parameter names for monitors and servers now use a set of constant
names. This removes some of the errors caused by spelling mistakes when
the same parameter name is repeated in multiple places.

The service, filter and listener parameters should also be converted to
constants. This allows for a consistent user experience.
This commit is contained in:
Markus Mäkelä 2017-04-19 23:22:38 +03:00 committed by Markus Mäkelä
parent 9aa4138705
commit 695a4032ca
8 changed files with 266 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Documentation/Getting-Started/Configuration-Guide.md
View File

@ -1391,8 +1391,8 @@ The following list of service parameters can be updated at runtime.
* max_slave_connections
* max_slave_replication_lag
In addition to these parameters, the server specific user credentials, _monuser_
and _monpw_, can also be updated at runtime.
In addition to these parameters, the server specific user credentials, _monitoruser_
and _monitorpw_, can also be updated at runtime.
### Limitations

26
include/maxscale/config.h
View File

@ -33,6 +33,30 @@ MXS_BEGIN_DECLS
#define MAX_ADMIN_USER_LEN 1024
#define MAX_ADMIN_PW_LEN 1024
/**
* Common configuration parameters names
*/
extern const char CN_PASSWORD[];
extern const char CN_USER[];
extern const char CN_ADDRESS[];
extern const char CN_NAME[];
extern const char CN_PORT[];
extern const char CN_MODULE[];
extern const char CN_TYPE[];
extern const char CN_PROTOCOL[];
extern const char CN_DEFAULT[];
extern const char CN_SERVERS[];
extern const char CN_SSL[];
extern const char CN_SSL_KEY[];
extern const char CN_SSL_CERT[];
extern const char CN_SSL_CA_CERT[];
extern const char CN_SSL_VERSION[];
extern const char CN_SSL_CERT_VERIFY_DEPTH[];
extern const char CN_AUTHENTICATOR[];
extern const char CN_AUTHENTICATOR_OPTIONS[];
/**
* The config parameter
*/
@ -310,6 +334,4 @@ void config_disable_feedback_task(void);
*/
bool config_reload(void);
static const char BACKEND_CONNECT_ATTEMPTS[] = "backend_connect_attempts";
MXS_END_DECLS

11
include/maxscale/monitor.h
View File

@ -237,6 +237,17 @@ static const char MXS_MONITOR_EVENT_DEFAULT_VALUE[] = "master_down,master_up,sla
"ndb_down,ndb_up,lost_master,lost_slave,lost_synced,lost_donor,lost_ndb,"
"new_master,new_slave,new_synced,new_donor,new_ndb";
/**
* Monitor configuration parameters names
*/
extern const char CN_BACKEND_CONNECT_ATTEMPTS[];
extern const char CN_BACKEND_READ_TIMEOUT[];
extern const char CN_BACKEND_WRITE_TIMEOUT[];
extern const char CN_BACKEND_CONNECT_TIMEOUT[];
extern const char CN_MONITOR_INTERVAL[];
extern const char CN_SCRIPT[];
extern const char CN_EVENTS[];
bool check_monitor_permissions(MXS_MONITOR* monitor, const char* query);
void monitor_clear_pending_status(MXS_MONITOR_SERVERS *ptr, int bit);

11
include/maxscale/server.h
View File

@ -30,6 +30,15 @@ MXS_BEGIN_DECLS
#define MAX_SERVER_MONPW_LEN 512
#define MAX_NUM_SLAVES 128 /**< Maximum number of slaves under a single server*/
/**
* Server configuration parameters names
*/
extern const char CN_MONITORPW[];
extern const char CN_MONITORUSER[];
extern const char CN_PERSISTMAXTIME[];
extern const char CN_PERSISTPOOLMAX[];
extern const char CN_USE_PROXY_PROTOCOL[];
/**
* The server parameters used for weighting routing decissions
*/
@ -192,8 +201,6 @@ enum
(((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == \
(SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE))
extern const char USE_PROXY_PROTOCOL[];
/**
* @brief Allocate a new server
*

245
server/core/config.cc
View File

@ -80,6 +80,27 @@
using std::set;
using std::string;
const char CN_PASSWORD[] = "password";
const char CN_USER[] = "user";
const char CN_ADDRESS[] = "address";
const char CN_NAME[] = "name";
const char CN_PORT[] = "port";
const char CN_MODULE[] = "module";
const char CN_TYPE[] = "type";
const char CN_PROTOCOL[] = "protocol";
const char CN_DEFAULT[] = "default";
const char CN_SERVERS[] = "servers";
const char CN_SSL[] = "ssl";
const char CN_SSL_KEY[] = "ssl_key";
const char CN_SSL_CERT[] = "ssl_cert";
const char CN_SSL_CA_CERT[] = "ssl_ca_cert";
const char CN_SSL_VERSION[] = "ssl_version";
const char CN_SSL_CERT_VERIFY_DEPTH[] = "ssl_cert_verify_depth";
const char CN_AUTHENTICATOR[] = "authenticator";
const char CN_AUTHENTICATOR_OPTIONS[] = "authenticator_options";
typedef struct duplicate_context
{
HASHTABLE *hash;
@ -121,14 +142,14 @@ static bool is_persisted_config = false; /**< True if a persisted configuration
static const char *service_params[] =
{
"type",
CN_TYPE,
"router",
"router_options",
"servers",
CN_SERVERS,
"monitor",
"user",
CN_USER,
"passwd", // DEPRECATE: See config_get_password.
"password",
CN_PASSWORD,
"enable_root_user",
"max_retry_interval",
"max_connections",
@ -148,67 +169,67 @@ static const char *service_params[] =
static const char *listener_params[] =
{
"authenticator_options",
"type",
CN_AUTHENTICATOR_OPTIONS,
CN_TYPE,
"service",
"protocol",
"port",
"address",
CN_PROTOCOL,
CN_PORT,
CN_ADDRESS,
"socket",
"authenticator",
"ssl_cert",
"ssl_ca_cert",
"ssl",
"ssl_key",
"ssl_version",
"ssl_cert_verify_depth",
CN_AUTHENTICATOR,
CN_SSL_CERT,
CN_SSL_CA_CERT,
CN_SSL,
CN_SSL_KEY,
CN_SSL_VERSION,
CN_SSL_CERT_VERIFY_DEPTH,
NULL
};
static const char *monitor_params[] =
{
"type",
"module",
"servers",
"user",
CN_TYPE,
CN_MODULE,
CN_SERVERS,
CN_USER,
"passwd", // DEPRECATE: See config_get_password.
"password",
"script",
"events",
"monitor_interval",
"backend_connect_timeout",
"backend_read_timeout",
"backend_write_timeout",
BACKEND_CONNECT_ATTEMPTS,
CN_PASSWORD,
CN_SCRIPT,
CN_EVENTS,
CN_MONITOR_INTERVAL,
CN_BACKEND_CONNECT_TIMEOUT,
CN_BACKEND_READ_TIMEOUT,
CN_BACKEND_WRITE_TIMEOUT,
CN_BACKEND_CONNECT_ATTEMPTS,
NULL
};
static const char *filter_params[] =
{
"type",
"module",
CN_TYPE,
CN_MODULE,
NULL
};
static const char *server_params[] =
{
"type",
"protocol",
"port",
"address",
"authenticator",
"authenticator_options",
"monitoruser",
"monitorpw",
"persistpoolmax",
"persistmaxtime",
"ssl_cert",
"ssl_ca_cert",
"ssl",
"ssl_key",
"ssl_version",
"ssl_cert_verify_depth",
USE_PROXY_PROTOCOL,
CN_TYPE,
CN_PROTOCOL,
CN_PORT,
CN_ADDRESS,
CN_AUTHENTICATOR,
CN_AUTHENTICATOR_OPTIONS,
CN_MONITORUSER,
CN_MONITORPW,
CN_PERSISTPOOLMAX,
CN_PERSISTMAXTIME,
CN_SSL_CERT,
CN_SSL_CA_CERT,
CN_SSL,
CN_SSL_KEY,
CN_SSL_VERSION,
CN_SSL_CERT_VERIFY_DEPTH,
CN_USE_PROXY_PROTOCOL,
NULL
};
@ -824,7 +845,7 @@ process_config_context(CONFIG_CONTEXT *context)
obj = context;
while (obj)
{
char *type = config_get_value(obj->parameters, "type");
char *type = config_get_value(obj->parameters, CN_TYPE);
if (type)
{
if (!strcmp(type, "service"))
@ -858,7 +879,7 @@ process_config_context(CONFIG_CONTEXT *context)
obj = context;
while (obj)
{
char *type = config_get_value(obj->parameters, "type");
char *type = config_get_value(obj->parameters, CN_TYPE);
if (type)
{
if (!strcmp(type, "service"))
@ -941,7 +962,7 @@ config_get_value(MXS_CONFIG_PARAMETER *params, const char *name)
static char *
config_get_password(MXS_CONFIG_PARAMETER *params)
{
char *password = config_get_value(params, "password");
char *password = config_get_value(params, CN_PASSWORD);
char *passwd = config_get_value(params, "passwd");
if (password && passwd)
@ -1527,7 +1548,7 @@ SSL_LISTENER* make_ssl_structure (CONFIG_CONTEXT *obj, bool require_cert, int *e
int local_errors = 0;
SSL_LISTENER *new_ssl;
ssl = config_get_value(obj->parameters, "ssl");
ssl = config_get_value(obj->parameters, CN_SSL);
if (ssl)
{
@ -1538,11 +1559,11 @@ SSL_LISTENER* make_ssl_structure (CONFIG_CONTEXT *obj, bool require_cert, int *e
return NULL;
}
new_ssl->ssl_method_type = SERVICE_SSL_TLS_MAX;
ssl_cert = config_get_value(obj->parameters, "ssl_cert");
ssl_key = config_get_value(obj->parameters, "ssl_key");
ssl_ca_cert = config_get_value(obj->parameters, "ssl_ca_cert");
ssl_version = config_get_value(obj->parameters, "ssl_version");
ssl_cert_verify_depth = config_get_value(obj->parameters, "ssl_cert_verify_depth");
ssl_cert = config_get_value(obj->parameters, CN_SSL_CERT);
ssl_key = config_get_value(obj->parameters, CN_SSL_KEY);
ssl_ca_cert = config_get_value(obj->parameters, CN_SSL_CA_CERT);
ssl_version = config_get_value(obj->parameters, CN_SSL_VERSION);
ssl_cert_verify_depth = config_get_value(obj->parameters, CN_SSL_CERT_VERIFY_DEPTH);
new_ssl->ssl_init_done = false;
if (ssl_version)
@ -1779,7 +1800,7 @@ process_config_update(CONFIG_CONTEXT *context)
obj = context;
while (obj)
{
char *type = config_get_value(obj->parameters, "type");
char *type = config_get_value(obj->parameters, CN_TYPE);
if (type == NULL)
{
MXS_ERROR("Configuration object %s has no type.", obj->object);
@ -1813,7 +1834,7 @@ process_config_update(CONFIG_CONTEXT *context)
max_connections = config_get_value_string(obj->parameters, "max_connections");
max_queued_connections = config_get_value_string(obj->parameters, "max_queued_connections");
queued_connection_timeout = config_get_value_string(obj->parameters, "queued_connection_timeout");
user = config_get_value(obj->parameters, "user");
user = config_get_value(obj->parameters, CN_USER);
auth = config_get_password(obj->parameters);
auth_all_servers = config_get_value(obj->parameters, "auth_all_servers");
@ -1889,14 +1910,14 @@ process_config_update(CONFIG_CONTEXT *context)
}
else if (!strcmp(type, "server"))
{
char *address = config_get_value(obj->parameters, "address");
char *port = config_get_value(obj->parameters, "port");
char *address = config_get_value(obj->parameters, CN_ADDRESS);
char *port = config_get_value(obj->parameters, CN_PORT);
if (address && port &&
(server = server_find(address, atoi(port))) != NULL)
{
char *monuser = config_get_value(obj->parameters, "monuser");
char *monpw = config_get_value(obj->parameters, "monpw");
char *monuser = config_get_value(obj->parameters, CN_MONITORUSER);
char *monpw = config_get_value(obj->parameters, CN_MONITORPW);
server_update_credentials(server, monuser, monpw);
obj->element = server;
}
@ -1994,7 +2015,7 @@ check_config_objects(CONFIG_CONTEXT *context)
const char *type;
const char *module_type = NULL;
if (obj->parameters && (type = config_get_value(obj->parameters, "type")))
if (obj->parameters && (type = config_get_value(obj->parameters, CN_TYPE)))
{
if (!strcmp(type, "service"))
{
@ -2009,13 +2030,13 @@ check_config_objects(CONFIG_CONTEXT *context)
else if (!strcmp(type, "monitor"))
{
param_set = monitor_params;
module = config_get_value(obj->parameters, "module");
module = config_get_value(obj->parameters, CN_MODULE);
module_type = MODULE_MONITOR;
}
else if (!strcmp(type, "filter"))
{
param_set = filter_params;
module = config_get_value(obj->parameters, "module");
module = config_get_value(obj->parameters, CN_MODULE);
module_type = MODULE_FILTER;
}
}
@ -2688,7 +2709,7 @@ int create_new_service(CONFIG_CONTEXT *obj)
serviceEnableLocalhostMatchWildcardHost(service, config_truth_value(wildcard));
}
char *user = config_get_value(obj->parameters, "user");
char *user = config_get_value(obj->parameters, CN_USER);
char *auth = config_get_password(obj->parameters);
if (user && auth)
@ -2788,13 +2809,13 @@ bool is_normal_server_parameter(const char *param)
int create_new_server(CONFIG_CONTEXT *obj)
{
int error_count = 0;
char *address = config_get_value(obj->parameters, "address");
char *port = config_get_value(obj->parameters, "port");
char *protocol = config_get_value(obj->parameters, "protocol");
char *monuser = config_get_value(obj->parameters, "monitoruser");
char *monpw = config_get_value(obj->parameters, "monitorpw");
char *auth = config_get_value(obj->parameters, "authenticator");
char *auth_opts = config_get_value(obj->parameters, "authenticator_options");
char *address = config_get_value(obj->parameters, CN_ADDRESS);
char *port = config_get_value(obj->parameters, CN_PORT);
char *protocol = config_get_value(obj->parameters, CN_PROTOCOL);
char *monuser = config_get_value(obj->parameters, CN_MONITORUSER);
char *monpw = config_get_value(obj->parameters, CN_MONITORPW);
char *auth = config_get_value(obj->parameters, CN_AUTHENTICATOR);
char *auth_opts = config_get_value(obj->parameters, CN_AUTHENTICATOR_OPTIONS);
if (address && port && protocol)
{
@ -2828,7 +2849,7 @@ int create_new_server(CONFIG_CONTEXT *obj)
}
char *endptr;
const char *poolmax = config_get_value_string(obj->parameters, "persistpoolmax");
const char *poolmax = config_get_value_string(obj->parameters, CN_PERSISTPOOLMAX);
if (poolmax)
{
long int persistpoolmax = strtol(poolmax, &endptr, 0);
@ -2844,7 +2865,7 @@ int create_new_server(CONFIG_CONTEXT *obj)
}
}
const char *persistmax = config_get_value_string(obj->parameters, "persistmaxtime");
const char *persistmax = config_get_value_string(obj->parameters, CN_PERSISTMAXTIME);
if (persistmax)
{
long int persistmaxtime = strtol(persistmax, &endptr, 0);
@ -2860,7 +2881,7 @@ int create_new_server(CONFIG_CONTEXT *obj)
}
}
server->use_proxy_protocol = config_get_bool(obj->parameters, USE_PROXY_PROTOCOL);
server->use_proxy_protocol = config_get_bool(obj->parameters, CN_USE_PROXY_PROTOCOL);
MXS_CONFIG_PARAMETER *params = obj->parameters;
@ -2894,7 +2915,7 @@ int configure_new_service(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj)
{
int error_count = 0;
char *filters = config_get_value(obj->parameters, "filters");
char *servers = config_get_value(obj->parameters, "servers");
char *servers = config_get_value(obj->parameters, CN_SERVERS);
char *monitor = config_get_value(obj->parameters, "monitor");
char *roptions = config_get_value(obj->parameters, "router_options");
SERVICE *service = (SERVICE*)obj->element;
@ -2916,7 +2937,7 @@ int configure_new_service(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj)
{
if (strcmp(ctx->object, monitor) == 0)
{
servers = config_get_value(ctx->parameters, "servers");
servers = config_get_value(ctx->parameters, CN_SERVERS);
break;
}
}
@ -2993,7 +3014,7 @@ int create_new_monitor(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj, HASHTABLE*
{
int error_count = 0;
char *module = config_get_value(obj->parameters, "module");
char *module = config_get_value(obj->parameters, CN_MODULE);
if (module)
{
if ((obj->element = monitor_alloc(obj->object, module)) == NULL)
@ -3016,7 +3037,7 @@ int create_new_monitor(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj, HASHTABLE*
error_count++;
}
char *servers = config_get_value(obj->parameters, "servers");
char *servers = config_get_value(obj->parameters, CN_SERVERS);
if (error_count == 0)
{
@ -3033,7 +3054,7 @@ int create_new_monitor(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj, HASHTABLE*
error_count++;
}
char *interval_str = config_get_value(obj->parameters, "monitor_interval");
char *interval_str = config_get_value(obj->parameters, CN_MONITOR_INTERVAL);
if (interval_str)
{
char *endptr;
@ -3046,54 +3067,54 @@ int create_new_monitor(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj, HASHTABLE*
}
else
{
MXS_NOTICE("Invalid 'monitor_interval' parameter for monitor '%s', "
MXS_NOTICE("Invalid '%s' parameter for monitor '%s', "
"using default value of %d milliseconds.",
obj->object, MONITOR_DEFAULT_INTERVAL);
CN_MONITOR_INTERVAL, obj->object, MONITOR_DEFAULT_INTERVAL);
}
}
else
{
MXS_NOTICE("Monitor '%s' is missing the 'monitor_interval' parameter, "
MXS_NOTICE("Monitor '%s' is missing the '%s' parameter, "
"using default value of %d milliseconds.",
obj->object, MONITOR_DEFAULT_INTERVAL);
CN_MONITOR_INTERVAL, obj->object, MONITOR_DEFAULT_INTERVAL);
}
char *connect_timeout = config_get_value(obj->parameters, "backend_connect_timeout");
char *connect_timeout = config_get_value(obj->parameters, CN_BACKEND_CONNECT_TIMEOUT);
if (connect_timeout)
{
if (!monitorSetNetworkTimeout(monitor, MONITOR_CONNECT_TIMEOUT, atoi(connect_timeout)))
{
MXS_ERROR("Failed to set backend_connect_timeout");
MXS_ERROR("Failed to set '%s'", CN_BACKEND_CONNECT_TIMEOUT);
error_count++;
}
}
char *read_timeout = config_get_value(obj->parameters, "backend_read_timeout");
char *read_timeout = config_get_value(obj->parameters, CN_BACKEND_READ_TIMEOUT);
if (read_timeout)
{
if (!monitorSetNetworkTimeout(monitor, MONITOR_READ_TIMEOUT, atoi(read_timeout)))
{
MXS_ERROR("Failed to set backend_read_timeout");
MXS_ERROR("Failed to set '%s'", CN_BACKEND_READ_TIMEOUT);
error_count++;
}
}
char *write_timeout = config_get_value(obj->parameters, "backend_write_timeout");
char *write_timeout = config_get_value(obj->parameters, CN_BACKEND_WRITE_TIMEOUT);
if (write_timeout)
{
if (!monitorSetNetworkTimeout(monitor, MONITOR_WRITE_TIMEOUT, atoi(write_timeout)))
{
MXS_ERROR("Failed to set backend_write_timeout");
MXS_ERROR("Failed to set '%s'", CN_BACKEND_WRITE_TIMEOUT);
error_count++;
}
}
char *connect_attempts = config_get_value(obj->parameters, BACKEND_CONNECT_ATTEMPTS);
char *connect_attempts = config_get_value(obj->parameters, CN_BACKEND_CONNECT_ATTEMPTS);
if (connect_attempts)
{
if (!monitorSetNetworkTimeout(monitor, MONITOR_CONNECT_ATTEMPTS, atoi(connect_attempts)))
{
MXS_ERROR("Failed to set '%s'.", BACKEND_CONNECT_ATTEMPTS);
MXS_ERROR("Failed to set '%s'", CN_BACKEND_CONNECT_ATTEMPTS);
error_count++;
}
}
@ -3133,7 +3154,7 @@ int create_new_monitor(CONFIG_CONTEXT *context, CONFIG_CONTEXT *obj, HASHTABLE*
}
}
char *user = config_get_value(obj->parameters, "user");
char *user = config_get_value(obj->parameters, CN_USER);
char *passwd = config_get_password(obj->parameters);
if (user && passwd)
{
@ -3160,12 +3181,12 @@ int create_new_listener(CONFIG_CONTEXT *obj)
{
int error_count = 0;
char *raw_service_name = config_get_value(obj->parameters, "service");
char *port = config_get_value(obj->parameters, "port");
char *address = config_get_value(obj->parameters, "address");
char *protocol = config_get_value(obj->parameters, "protocol");
char *port = config_get_value(obj->parameters, CN_PORT);
char *address = config_get_value(obj->parameters, CN_ADDRESS);
char *protocol = config_get_value(obj->parameters, CN_PROTOCOL);
char *socket = config_get_value(obj->parameters, "socket");
char *authenticator = config_get_value(obj->parameters, "authenticator");
char *authenticator_options = config_get_value(obj->parameters, "authenticator_options");
char *authenticator = config_get_value(obj->parameters, CN_AUTHENTICATOR);
char *authenticator_options = config_get_value(obj->parameters, CN_AUTHENTICATOR_OPTIONS);
if (raw_service_name && protocol && (socket || port))
{
@ -3239,7 +3260,7 @@ int create_new_listener(CONFIG_CONTEXT *obj)
int create_new_filter(CONFIG_CONTEXT *obj)
{
int error_count = 0;
char *module = config_get_value(obj->parameters, "module");
char *module = config_get_value(obj->parameters, CN_MODULE);
if (module)
{
@ -3294,23 +3315,23 @@ bool config_have_required_ssl_params(CONFIG_CONTEXT *obj)
{
MXS_CONFIG_PARAMETER *param = obj->parameters;
return config_get_param(param, "ssl") &&
config_get_param(param, "ssl_key") &&
config_get_param(param, "ssl_cert") &&
config_get_param(param, "ssl_ca_cert") &&
strcmp(config_get_value_string(param, "ssl"), "required") == 0;
return config_get_param(param, CN_SSL) &&
config_get_param(param, CN_SSL_KEY) &&
config_get_param(param, CN_SSL_CERT) &&
config_get_param(param, CN_SSL_CA_CERT) &&
strcmp(config_get_value_string(param, CN_SSL), "required") == 0;
}
bool config_is_ssl_parameter(const char *key)
{
const char *ssl_params[] =
{
"ssl_cert",
"ssl_ca_cert",
"ssl",
"ssl_key",
"ssl_version",
"ssl_cert_verify_depth",
CN_SSL_CERT,
CN_SSL_CA_CERT,
CN_SSL,
CN_SSL_KEY,
CN_SSL_VERSION,
CN_SSL_CERT_VERIFY_DEPTH,
NULL
};
@ -3410,7 +3431,7 @@ static bool config_contains_type(const CONFIG_CONTEXT *ctx, const char *name, co
while (ctx)
{
if (strcmp(ctx->object, name) == 0 &&
strcmp(type, config_get_value_string(ctx->parameters, "type")) == 0)
strcmp(type, config_get_value_string(ctx->parameters, CN_TYPE)) == 0)
{
return true;
}

70
server/core/config_runtime.cc
View File

@ -217,12 +217,12 @@ static SSL_LISTENER* create_ssl(const char *name, const char *key, const char *c
if (obj)
{
if (config_add_param(obj, "ssl", "required") &&
config_add_param(obj, "ssl_key", key) &&
config_add_param(obj, "ssl_cert", cert) &&
config_add_param(obj, "ssl_ca_cert", ca) &&
(!version || config_add_param(obj, "ssl_version", version)) &&
(!depth || config_add_param(obj, "ssl_cert_verify_depth", depth)))
if (config_add_param(obj, CN_SSL, "required") &&
config_add_param(obj, CN_SSL_KEY, key) &&
config_add_param(obj, CN_SSL_CERT, cert) &&
config_add_param(obj, CN_SSL_CA_CERT, ca) &&
(!version || config_add_param(obj, CN_SSL_VERSION, version)) &&
(!depth || config_add_param(obj, CN_SSL_CERT_VERIFY_DEPTH, depth)))
{
int err = 0;
SSL_LISTENER *ssl = make_ssl_structure(obj, true, &err);
@ -276,19 +276,19 @@ bool runtime_alter_server(SERVER *server, char *key, char *value)
spinlock_acquire(&crt_lock);
bool valid = true;
if (strcmp(key, "address") == 0)
if (strcmp(key, CN_ADDRESS) == 0)
{
server_update_address(server, value);
}
else if (strcmp(key, "port") == 0)
else if (strcmp(key, CN_PORT) == 0)
{
server_update_port(server, atoi(value));
}
else if (strcmp(key, "monuser") == 0)
else if (strcmp(key, CN_MONITORUSER) == 0)
{
server_update_credentials(server, value, server->monpw);
}
else if (strcmp(key, "monpw") == 0)
else if (strcmp(key, CN_MONITORPW) == 0)
{
server_update_credentials(server, server->monuser, value);
}
@ -375,17 +375,17 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, char *key, char *value)
spinlock_acquire(&crt_lock);
bool valid = false;
if (strcmp(key, "user") == 0)
if (strcmp(key, CN_USER) == 0)
{
valid = true;
monitorAddUser(monitor, value, monitor->password);
}
else if (strcmp(key, "password") == 0)
else if (strcmp(key, CN_PASSWORD) == 0)
{
valid = true;
monitorAddUser(monitor, monitor->user, value);
}
else if (strcmp(key, "monitor_interval") == 0)
else if (strcmp(key, CN_MONITOR_INTERVAL) == 0)
{
long ival = get_positive_int(value);
if (ival)
@ -394,7 +394,7 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, char *key, char *value)
monitorSetInterval(monitor, ival);
}
}
else if (strcmp(key, "backend_connect_timeout") == 0)
else if (strcmp(key, CN_BACKEND_CONNECT_TIMEOUT) == 0)
{
long ival = get_positive_int(value);
if (ival)
@ -403,7 +403,7 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, char *key, char *value)
monitorSetNetworkTimeout(monitor, MONITOR_CONNECT_TIMEOUT, ival);
}
}
else if (strcmp(key, "backend_write_timeout") == 0)
else if (strcmp(key, CN_BACKEND_WRITE_TIMEOUT) == 0)
{
long ival = get_positive_int(value);
if (ival)
@ -412,7 +412,7 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, char *key, char *value)
monitorSetNetworkTimeout(monitor, MONITOR_WRITE_TIMEOUT, ival);
}
}
else if (strcmp(key, "backend_read_timeout") == 0)
else if (strcmp(key, CN_BACKEND_READ_TIMEOUT) == 0)
{
long ival = get_positive_int(value);
if (ival)
@ -421,7 +421,7 @@ bool runtime_alter_monitor(MXS_MONITOR *monitor, char *key, char *value)
monitorSetNetworkTimeout(monitor, MONITOR_READ_TIMEOUT, ival);
}
}
else if (strcmp(key, BACKEND_CONNECT_ATTEMPTS) == 0)
else if (strcmp(key, CN_BACKEND_CONNECT_ATTEMPTS) == 0)
{
long ival = get_positive_int(value);
if (ival)
@ -475,26 +475,26 @@ bool runtime_create_listener(SERVICE *service, const char *name, const char *add
const char *ssl_version, const char *ssl_depth)
{
if (addr == NULL || strcasecmp(addr, "default") == 0)
if (addr == NULL || strcasecmp(addr, CN_DEFAULT) == 0)
{
addr = "::";
}
if (port == NULL || strcasecmp(port, "default") == 0)
if (port == NULL || strcasecmp(port, CN_DEFAULT) == 0)
{
port = "3306";
}
if (proto == NULL || strcasecmp(proto, "default") == 0)
if (proto == NULL || strcasecmp(proto, CN_DEFAULT) == 0)
{
proto = "MySQLClient";
}
if (auth && strcasecmp(auth, "default") == 0)
if (auth && strcasecmp(auth, CN_DEFAULT) == 0)
{
/** Set auth to NULL so the protocol default authenticator is used */
auth = NULL;
}
if (auth_opt && strcasecmp(auth_opt, "default") == 0)
if (auth_opt && strcasecmp(auth_opt, CN_DEFAULT) == 0)
{
/** Don't pass options to the authenticator */
auth_opt = NULL;
@ -735,9 +735,9 @@ static bool server_contains_required_fields(json_t* json)
{
json_t* value;
return (value = json_object_get(json, "name")) && json_is_string(value) &&
(value = json_object_get(json, "address")) && json_is_string(value) &&
(value = json_object_get(json, "port")) && json_is_integer(value);
return (value = json_object_get(json, CN_NAME)) && json_is_string(value) &&
(value = json_object_get(json, CN_ADDRESS)) && json_is_string(value) &&
(value = json_object_get(json, CN_PORT)) && json_is_integer(value);
}
const char* server_relation_types[] =
@ -791,18 +791,18 @@ SERVER* runtime_create_server_from_json(json_t* json)
if (server_contains_required_fields(json))
{
const char* name = json_string_value(json_object_get(json, "name"));
const char* address = json_string_value(json_object_get(json, "address"));
const char* name = json_string_value(json_object_get(json, CN_NAME));
const char* address = json_string_value(json_object_get(json, CN_ADDRESS));
/** The port needs to be in string format */
char port[200]; // Enough to store any port value
int i = json_integer_value(json_object_get(json, "port"));
int i = json_integer_value(json_object_get(json, CN_PORT));
snprintf(port, sizeof (port), "%d", i);
/** Optional parameters */
const char* protocol = string_or_null(json, "protocol");
const char* authenticator = string_or_null(json, "authenticator");
const char* authenticator_options = string_or_null(json, "authenticator_options");
const char* protocol = string_or_null(json, CN_PROTOCOL);
const char* authenticator = string_or_null(json, CN_AUTHENTICATOR);
const char* authenticator_options = string_or_null(json, CN_AUTHENTICATOR_OPTIONS);
set<string> relations;
@ -828,8 +828,8 @@ static bool monitor_contains_required_fields(json_t* json)
{
json_t* value;
return (value = json_object_get(json, "name")) && json_is_string(value) &&
(value = json_object_get(json, "module")) && json_is_string(value);
return (value = json_object_get(json, CN_NAME)) && json_is_string(value) &&
(value = json_object_get(json, CN_MODULE)) && json_is_string(value);
}
const char* monitor_relation_types[] =
@ -886,8 +886,8 @@ MXS_MONITOR* runtime_create_monitor_from_json(json_t* json)
if (monitor_contains_required_fields(json))
{
const char* name = json_string_value(json_object_get(json, "name"));
const char* module = json_string_value(json_object_get(json, "module"));
const char* name = json_string_value(json_object_get(json, CN_NAME));
const char* module = json_string_value(json_object_get(json, CN_MODULE));
set<string> relations;

45
server/core/monitor.cc
View File

@ -51,6 +51,14 @@
using std::string;
const char CN_BACKEND_CONNECT_ATTEMPTS[] = "backend_connect_attempts";
const char CN_BACKEND_READ_TIMEOUT[] = "backend_read_timeout";
const char CN_BACKEND_WRITE_TIMEOUT[] = "backend_write_timeout";
const char CN_BACKEND_CONNECT_TIMEOUT[] = "backend_connect_timeout";
const char CN_MONITOR_INTERVAL[] = "monitor_interval";
const char CN_SCRIPT[] = "monitor_interval";
const char CN_EVENTS[] = "monitor_interval";
static MXS_MONITOR *allMonitors = NULL;
static SPINLOCK monLock = SPINLOCK_INIT;
@ -1309,7 +1317,7 @@ static bool create_monitor_server_config(const MXS_MONITOR *monitor, const char
if (monitor->databases)
{
dprintf(file, "servers=");
dprintf(file, "%s=", CN_SERVERS);
for (MXS_MONITOR_SERVERS *db = monitor->databases; db; db = db->next)
{
if (db != monitor->databases)
@ -1344,15 +1352,15 @@ static bool create_monitor_config(const MXS_MONITOR *monitor, const char *filena
* TODO: Check for return values on all of the dprintf calls
*/
dprintf(file, "[%s]\n", monitor->name);
dprintf(file, "type=monitor\n");
dprintf(file, "module=%s\n", monitor->module_name);
dprintf(file, "user=%s\n", monitor->user);
dprintf(file, "password=%s\n", monitor->password);
dprintf(file, "monitor_interval=%lu\n", monitor->interval);
dprintf(file, "backend_connect_timeout=%d\n", monitor->connect_timeout);
dprintf(file, "backend_write_timeout=%d\n", monitor->write_timeout);
dprintf(file, "backend_read_timeout=%d\n", monitor->read_timeout);
dprintf(file, "%s=%d\n", BACKEND_CONNECT_ATTEMPTS, monitor->connect_attempts);
dprintf(file, "%s=monitor\n", CN_TYPE);
dprintf(file, "%s=%s\n", CN_MODULE, monitor->module_name);
dprintf(file, "%s=%s\n", CN_USER, monitor->user);
dprintf(file, "%s=%s\n", CN_PASSWORD, monitor->password);
dprintf(file, "%s=%lu\n", CN_MONITOR_INTERVAL, monitor->interval);
dprintf(file, "%s=%d\n", CN_BACKEND_CONNECT_TIMEOUT, monitor->connect_timeout);
dprintf(file, "%s=%d\n", CN_BACKEND_WRITE_TIMEOUT, monitor->write_timeout);
dprintf(file, "%s=%d\n", CN_BACKEND_READ_TIMEOUT, monitor->read_timeout);
dprintf(file, "%s=%d\n", CN_BACKEND_CONNECT_ATTEMPTS, monitor->connect_attempts);
close(file);
@ -1543,17 +1551,16 @@ json_t* monitor_to_json(const MXS_MONITOR* monitor, const char* host)
{
json_t* rval = json_object();
json_object_set_new(rval, "name", json_string(monitor->name));
json_object_set_new(rval, "module", json_string(monitor->module_name));
json_object_set_new(rval, CN_NAME, json_string(monitor->name));
json_object_set_new(rval, CN_MODULE, json_string(monitor->module_name));
json_object_set_new(rval, CN_MONITOR_INTERVAL, json_integer(monitor->interval));
json_object_set_new(rval, CN_BACKEND_CONNECT_TIMEOUT, json_integer(monitor->connect_timeout));
json_object_set_new(rval, CN_BACKEND_READ_TIMEOUT, json_integer(monitor->read_timeout));
json_object_set_new(rval, CN_BACKEND_WRITE_TIMEOUT, json_integer(monitor->write_timeout));
json_object_set_new(rval, CN_BACKEND_CONNECT_ATTEMPTS, json_integer(monitor->connect_attempts));
json_object_set_new(rval, "state", json_string(monitor_state_to_string(monitor->state)));
json_object_set_new(rval, "monitor_interval", json_integer(monitor->interval));
json_object_set_new(rval, "connect_timeout", json_integer(monitor->connect_timeout));
json_object_set_new(rval, "read_timeout", json_integer(monitor->read_timeout));
json_object_set_new(rval, "write_timeout", json_integer(monitor->write_timeout));
json_object_set_new(rval, "connect_attempts", json_integer(monitor->connect_attempts));
json_t* rel = json_object();
if (monitor->databases)

49
server/core/server.cc
View File

@ -64,7 +64,11 @@ using maxscale::WorkerTask;
/** The latin1 charset */
#define SERVER_DEFAULT_CHARSET 0x08
const char USE_PROXY_PROTOCOL[] = "use_proxy_protocol";
const char CN_MONITORPW[] = "monitorpw";
const char CN_MONITORUSER[] = "monitoruser";
const char CN_PERSISTMAXTIME[] = "persistmaxtime";
const char CN_PERSISTPOOLMAX[] = "persistpoolmax";
const char CN_USE_PROXY_PROTOCOL[] = "use_proxy_protocol";
static SPINLOCK server_spin = SPINLOCK_INIT;
static SERVER *allServers = NULL;
@ -1132,36 +1136,36 @@ static bool create_server_config(const SERVER *server, const char *filename)
// TODO: Check for return values on all of the dprintf calls
dprintf(file, "[%s]\n", server->unique_name);
dprintf(file, "type=server\n");
dprintf(file, "protocol=%s\n", server->protocol);
dprintf(file, "address=%s\n", server->name);
dprintf(file, "port=%u\n", server->port);
dprintf(file, "authenticator=%s\n", server->authenticator);
dprintf(file, "%s=server\n", CN_TYPE);
dprintf(file, "%s=%s\n", CN_PROTOCOL, server->protocol);
dprintf(file, "%s=%s\n", CN_ADDRESS, server->name);
dprintf(file, "%s=%u\n", CN_PORT, server->port);
dprintf(file, "%s=%s\n", CN_AUTHENTICATOR, server->authenticator);
if (server->auth_options)
{
dprintf(file, "authenticator_options=%s\n", server->auth_options);
dprintf(file, "%s=%s\n", CN_AUTHENTICATOR_OPTIONS, server->auth_options);
}
if (*server->monpw && *server->monuser)
{
dprintf(file, "monitoruser=%s\n", server->monuser);
dprintf(file, "monitorpw=%s\n", server->monpw);
dprintf(file, "%s=%s\n", CN_MONITORUSER, server->monuser);
dprintf(file, "%s=%s\n", CN_MONITORPW, server->monpw);
}
if (server->persistpoolmax)
{
dprintf(file, "persistpoolmax=%ld\n", server->persistpoolmax);
dprintf(file, "%s=%ld\n", CN_PERSISTPOOLMAX, server->persistpoolmax);
}
if (server->persistmaxtime)
{
dprintf(file, "persistmaxtime=%ld\n", server->persistmaxtime);
dprintf(file, "%s=%ld\n", CN_PERSISTMAXTIME, server->persistmaxtime);
}
if (server->use_proxy_protocol)
{
dprintf(file, "%s=yes\n", USE_PROXY_PROTOCOL);
dprintf(file, "%s=yes\n", CN_USE_PROXY_PROTOCOL);
}
for (SERVER_PARAM *p = server->parameters; p; p = p->next)
@ -1174,25 +1178,25 @@ static bool create_server_config(const SERVER *server, const char *filename)
if (server->server_ssl)
{
dprintf(file, "ssl=required\n");
dprintf(file, "%s=required\n", CN_SSL);
if (server->server_ssl->ssl_cert)
{
dprintf(file, "ssl_cert=%s\n", server->server_ssl->ssl_cert);
dprintf(file, "%s=%s\n", CN_SSL_CERT, server->server_ssl->ssl_cert);
}
if (server->server_ssl->ssl_key)
{
dprintf(file, "ssl_key=%s\n", server->server_ssl->ssl_key);
dprintf(file, "%s=%s\n", CN_SSL_KEY, server->server_ssl->ssl_key);
}
if (server->server_ssl->ssl_ca_cert)
{
dprintf(file, "ssl_ca_cert=%s\n", server->server_ssl->ssl_ca_cert);
dprintf(file, "%s=%s\n", CN_SSL_CA_CERT, server->server_ssl->ssl_ca_cert);
}
if (server->server_ssl->ssl_cert_verify_depth)
{
dprintf(file, "ssl_cert_verify_depth=%d\n", server->server_ssl->ssl_cert_verify_depth);
dprintf(file, "%s=%d\n", CN_SSL_CERT_VERIFY_DEPTH, server->server_ssl->ssl_cert_verify_depth);
}
const char *version = NULL;
@ -1222,7 +1226,7 @@ static bool create_server_config(const SERVER *server, const char *filename)
if (version)
{
dprintf(file, "ssl_version=%s\n", version);
dprintf(file, "%s=%s\n", CN_SSL_VERSION, version);
}
}
@ -1402,16 +1406,15 @@ json_t* server_to_json(const SERVER* server, const char* host)
// TODO: Add error checks
json_t* rval = json_object();
json_object_set_new(rval, "name", json_string(server->unique_name));
json_object_set_new(rval, "address", json_string(server->name));
json_object_set_new(rval, "port", json_integer(server->port));
json_object_set_new(rval, CN_NAME, json_string(server->unique_name));
json_object_set_new(rval, CN_ADDRESS, json_string(server->name));
json_object_set_new(rval, CN_PORT, json_integer(server->port));
json_object_set_new(rval, CN_PROTOCOL, json_string(server->protocol));
char* stat = server_status(server);
json_object_set_new(rval, "status", json_string(stat));
MXS_FREE(stat);
json_object_set_new(rval, "protocol", json_string(server->protocol));
if (server->server_string)
{
json_object_set_new(rval, "version", json_string(server->server_string));