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

MXS-2304 Convert static config parameter methods to non-static

Browse Source 
Parameter handling changed in several places.
This commit is contained in:
Esa Korhonen 2019-02-18 18:31:59 +02:00
parent b64e9b3ee0
commit 5828c93112
16 changed files with 138 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/maxscale/config.hh
View File

@ -362,33 +362,29 @@ public:
* to handle the special case of params being empty. This is needed until the config management
* has been properly refactored.
*
* @param ppParams Double pointer to the parameters structure to edit
* @param key Parameter key
* @param value Value to set
*/
static void set(MXS_CONFIG_PARAMETER** ppParams, const std::string& key, const std::string& value);
void set(const std::string& key, const std::string& value);
/**
* Copy all key-value pairs from a set to this container. If a key doesn't exist, it is added.
*
* @param destination Destination of the copied parameters
* @param source Parameters to copy
*/
static void set_multiple(MXS_CONFIG_PARAMETER** destination, const MXS_CONFIG_PARAMETER* source);
void set_multiple(const MXS_CONFIG_PARAMETER& source);
static void set_from_list(MXS_CONFIG_PARAMETER** destination,
std::vector<std::pair<const char*, const char*>> list,
const MXS_MODULE_PARAM* module_params = NULL);
void set_from_list(std::vector<std::pair<const char*, const char*>> list,
const MXS_MODULE_PARAM* module_params = NULL);
/**
* Remove a key-value pair from the container.
*
* @param ppParams Parameters container
* @param key Key to remove
*/
static void remove(MXS_CONFIG_PARAMETER** ppParams, const std::string& key);
void remove(const std::string& key);
static void free_all(MXS_CONFIG_PARAMETER** ppParams);
void clear();
ContainerType::const_iterator begin() const;
ContainerType::const_iterator end() const;
@ -404,6 +400,10 @@ private:
class CONFIG_CONTEXT
{
public:
CONFIG_CONTEXT();
CONFIG_CONTEXT(const std::string& section);
~CONFIG_CONTEXT();
char* object; /**< The name of the object being configured */
MXS_CONFIG_PARAMETER* parameters; /**< The list of parameter values */
bool was_persisted; /**< True if this object was persisted */

3
include/maxscale/service.hh
View File

@ -156,7 +156,8 @@ public:
protected:
SERVICE(const std::string& name,
const std::string& router_name)
: m_name(name) /** Service name. */
: svc_config_param(new MXS_CONFIG_PARAMETER)
, m_name(name) /** Service name. */
, m_router_name(router_name) /** Router module. */
{
}

90
server/core/config.cc
View File

@ -601,18 +601,32 @@ char* config_clean_string_list(const char* str)
return dest;
}
CONFIG_CONTEXT::CONFIG_CONTEXT()
: object(nullptr)
, parameters(new MXS_CONFIG_PARAMETER)
, was_persisted(is_persisted_config)
, next(nullptr)
{
}
CONFIG_CONTEXT::CONFIG_CONTEXT(const string& section)
: CONFIG_CONTEXT()
{
object = MXS_STRDUP_A(section.c_str());
}
CONFIG_CONTEXT::~CONFIG_CONTEXT()
{
delete parameters;
if (object)
{
MXS_FREE(object);
}
}
CONFIG_CONTEXT* config_context_create(const char* section)
{
CONFIG_CONTEXT* ctx = (CONFIG_CONTEXT*)MXS_MALLOC(sizeof(CONFIG_CONTEXT));
if (ctx)
{
ctx->object = MXS_STRDUP_A(section);
ctx->was_persisted = is_persisted_config;
ctx->parameters = NULL;
ctx->next = NULL;
}
return ctx;
return new CONFIG_CONTEXT(section);
}
void fix_object_name(char* name)
@ -1857,13 +1871,10 @@ void config_free_one_param(MXS_CONFIG_PARAMETER* p1)
void config_context_free(CONFIG_CONTEXT* context)
{
CONFIG_CONTEXT* obj;
while (context)
{
obj = context->next;
MXS_CONFIG_PARAMETER::free_all(&context->parameters);
MXS_FREE(context->object);
MXS_FREE(context);
delete context;
context = obj;
}
}
@ -1871,7 +1882,7 @@ void config_context_free(CONFIG_CONTEXT* context)
bool config_add_param(CONFIG_CONTEXT* obj, const char* key, const char* value)
{
mxb_assert(!obj->parameters->contains(key));
MXS_CONFIG_PARAMETER::set(&obj->parameters, key, value);
obj->parameters->set(key, value);
return true;
}
@ -1885,41 +1896,33 @@ bool config_append_param(CONFIG_CONTEXT* obj, const char* key, const char* value
bool rval = false;
if (new_val_z)
{
MXS_CONFIG_PARAMETER::set(&obj->parameters, key, new_val_z);
obj->parameters->set(key, new_val_z);
MXS_FREE(new_val_z);
rval = true;
}
return rval;
}
void MXS_CONFIG_PARAMETER::set(MXS_CONFIG_PARAMETER** ppParams, const string& key, const string& value)
void MXS_CONFIG_PARAMETER::set(const std::string& key, const std::string& value)
{
mxb_assert(ppParams);
if (*ppParams == nullptr)
{
// This is the first parameter.
*ppParams = new MXS_CONFIG_PARAMETER();
}
(*ppParams)->m_contents[key] = value;
m_contents[key] = value;
}
void MXS_CONFIG_PARAMETER::set_multiple(MXS_CONFIG_PARAMETER** destination, const MXS_CONFIG_PARAMETER* source)
void MXS_CONFIG_PARAMETER::set_multiple(const MXS_CONFIG_PARAMETER& source)
{
for (const auto& elem : *source)
for (const auto& elem : source)
{
set(destination, elem.first, elem.second);
set(elem.first, elem.second);
}
}
void MXS_CONFIG_PARAMETER::set_from_list(MXS_CONFIG_PARAMETER** destination,
std::vector<std::pair<const char*, const char*>> list,
void MXS_CONFIG_PARAMETER::set_from_list(std::vector<std::pair<const char*, const char*>> list,
const MXS_MODULE_PARAM* module_params)
{
// Add custom values.
for (const auto& a : list)
{
MXS_CONFIG_PARAMETER::set(destination, a.first, a.second);
set(a.first, a.second);
}
if (module_params)
@ -1927,29 +1930,22 @@ void MXS_CONFIG_PARAMETER::set_from_list(MXS_CONFIG_PARAMETER** destination,
// Add default values for the rest of the parameters.
for (auto module_param = module_params; module_param->name; module_param++)
{
if (module_param->default_value && !(*destination)->contains(module_param->name))
if (module_param->default_value && !contains(module_param->name))
{
MXS_CONFIG_PARAMETER::set(destination, module_param->name, module_param->default_value);
set(module_param->name, module_param->default_value);
}
}
}
}
void MXS_CONFIG_PARAMETER::remove(MXS_CONFIG_PARAMETER** ppParams, const string& key)
void MXS_CONFIG_PARAMETER::remove(const string& key)
{
mxb_assert(ppParams);
(*ppParams)->m_contents.erase(key);
m_contents.erase(key);
}
void MXS_CONFIG_PARAMETER::free_all(MXS_CONFIG_PARAMETER** ppParams)
void MXS_CONFIG_PARAMETER::clear()
{
mxb_assert(ppParams);
auto pParam = *ppParams;
if (pParam)
{
delete pParam;
}
*ppParams = nullptr;
m_contents.clear();
}
MXS_CONFIG_PARAMETER::ContainerType::const_iterator MXS_CONFIG_PARAMETER::begin() const
@ -1964,13 +1960,13 @@ MXS_CONFIG_PARAMETER::ContainerType::const_iterator MXS_CONFIG_PARAMETER::end()
bool config_replace_param(CONFIG_CONTEXT* obj, const char* key, const char* value)
{
MXS_CONFIG_PARAMETER::set(&obj->parameters, key, value);
obj->parameters->set(key, value);
return true;
}
void config_remove_param(CONFIG_CONTEXT* obj, const char* name)
{
MXS_CONFIG_PARAMETER::remove(&obj->parameters, name);
obj->parameters->remove(name);
}
/**
@ -3019,7 +3015,7 @@ static bool check_config_objects(CONFIG_CONTEXT* context)
{
config_fix_param(fix_params, param_namez, &temp);
}
MXS_CONFIG_PARAMETER::set(&obj->parameters, param_namez, temp);
obj->parameters->set(param_namez, temp);
if (param_is_deprecated(fix_params, param_namez, obj->object))
{

31
server/core/config_runtime.cc
View File

@ -285,7 +285,7 @@ bool runtime_create_server(const char* name,
name);
}
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
delete ctx.parameters;
}
else
{
@ -606,7 +606,7 @@ bool do_alter_monitor(Monitor* monitor, const char* key, const char* value)
}
std::lock_guard<std::mutex> guard(crt_lock);
MXS_CONFIG_PARAMETER::set(&monitor->parameters, key, value);
monitor->parameters->set(key, value);
bool success = true;
if (strcmp(key, CN_USER) == 0)
{
@ -1224,7 +1224,7 @@ bool runtime_create_monitor(const char* name, const char* module)
config_runtime_error("Could not create monitor '%s' with module '%s'", name, module);
}
MXS_CONFIG_PARAMETER::free_all(&params);
delete params;
}
}
else
@ -1281,7 +1281,7 @@ bool runtime_create_filter(const char* name, const char* module, MXS_CONFIG_PARA
config_runtime_error("Could not create filter '%s' with module '%s'", name, module);
}
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
delete ctx.parameters;
}
else
{
@ -1358,7 +1358,7 @@ static bool runtime_create_service(const char* name, const char* router, MXS_CON
config_runtime_error("Could not create service '%s' with module '%s'", name, router);
}
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
delete ctx.parameters;
}
else
{
@ -1443,10 +1443,9 @@ bool runtime_destroy_monitor(Monitor* monitor)
return rval;
}
static MXS_CONFIG_PARAMETER* extract_parameters_from_json(json_t* json)
static MXS_CONFIG_PARAMETER extract_parameters_from_json(json_t* json)
{
CONFIG_CONTEXT ctx {(char*)""};
MXS_CONFIG_PARAMETER rval;
if (json_t* parameters = mxs_json_pointer(json, MXS_JSON_PTR_PARAMETERS))
{
const char* key;
@ -1454,11 +1453,11 @@ static MXS_CONFIG_PARAMETER* extract_parameters_from_json(json_t* json)
json_object_foreach(parameters, key, value)
{
config_add_param(&ctx, key, json_string_value(value));
rval.set(key, json_string_value(value));
}
}
return ctx.parameters;
return rval;
}
static bool extract_ordered_relations(json_t* json,
@ -2283,11 +2282,9 @@ bool runtime_create_filter_from_json(json_t* json)
{
const char* name = json_string_value(mxs_json_pointer(json, MXS_JSON_PTR_ID));
const char* module = json_string_value(mxs_json_pointer(json, MXS_JSON_PTR_MODULE));
MXS_CONFIG_PARAMETER* params = extract_parameters_from_json(json);
auto params = extract_parameters_from_json(json);
rval = runtime_create_filter(name, module, params);
MXS_CONFIG_PARAMETER::free_all(&params);
rval = runtime_create_filter(name, module, &params);
}
return rval;
@ -2301,9 +2298,9 @@ Service* runtime_create_service_from_json(json_t* json)
{
const char* name = json_string_value(mxs_json_pointer(json, MXS_JSON_PTR_ID));
const char* router = json_string_value(mxs_json_pointer(json, MXS_JSON_PTR_ROUTER));
MXS_CONFIG_PARAMETER* params = extract_parameters_from_json(json);
auto params = extract_parameters_from_json(json);
if (runtime_create_service(name, router, params))
if (runtime_create_service(name, router, &params))
{
rval = service_internal_find(name);
mxb_assert(rval);
@ -2320,8 +2317,6 @@ Service* runtime_create_service_from_json(json_t* json)
serviceStart(rval);
}
}
MXS_CONFIG_PARAMETER::free_all(&params);
}
return rval;

12
server/core/filter.cc
View File

@ -59,7 +59,7 @@ static struct
*/
static void filter_free_parameters(FilterDef* filter)
{
MXS_CONFIG_PARAMETER::free_all(&filter->parameters);
delete filter->parameters;
}
/**
@ -116,18 +116,14 @@ FilterDef::FilterDef(std::string name,
, obj(object)
{
// TODO: Add config_clone_param_chain
CONFIG_CONTEXT ctx = {};
ctx.object = (char*)"";
parameters = new MXS_CONFIG_PARAMETER;
for (auto p : *params)
{
config_add_param(&ctx, p.first.c_str(), p.second.c_str());
parameters->set(p.first, p.second);
}
// Store module, used when the filter is serialized
config_replace_param(&ctx, CN_MODULE, module.c_str());
parameters = ctx.parameters;
parameters->set(CN_MODULE, module);
}
FilterDef::~FilterDef()

7
server/core/monitor.cc
View File

@ -184,6 +184,7 @@ Monitor::Monitor(const string& name, const string& module)
, m_module(module)
{
memset(m_journal_hash, 0, sizeof(m_journal_hash));
parameters = new MXS_CONFIG_PARAMETER;
}
void Monitor::stop()
@ -235,16 +236,16 @@ bool Monitor::configure_base(const MXS_CONFIG_PARAMETER* params)
if (!error)
{
// Store module name into parameter storage.
MXS_CONFIG_PARAMETER::set(&parameters, CN_MODULE, m_module);
parameters->set(CN_MODULE, m_module);
// Add all config settings to text-mode storage. Needed for serialization.
MXS_CONFIG_PARAMETER::set_multiple(&parameters, params);
parameters->set_multiple(*params);
}
return !error;
}
Monitor::~Monitor()
{
MXS_CONFIG_PARAMETER::free_all(&parameters);
delete parameters;
monitor_server_free_all(m_servers);
MXS_FREE((const_cast<char*>(m_name)));
}

5
server/core/server.cc
View File

@ -117,15 +117,16 @@ class ParamAdaptor
public:
ParamAdaptor(const std::vector<Server::ConfigParameter>& parameters)
{
m_params = new MXS_CONFIG_PARAMETER;
for (const auto& elem : parameters)
{
MXS_CONFIG_PARAMETER::set(&m_params, elem.name, elem.value);
m_params->set(elem.name, elem.value);
}
}
~ParamAdaptor()
{
MXS_CONFIG_PARAMETER::free_all(&m_params);
delete m_params;
}
operator MXS_CONFIG_PARAMETER*()

19
server/core/service.cc
View File

@ -91,6 +91,13 @@ Service* service_alloc(const char* name, const char* router, MXS_CONFIG_PARAMETE
return NULL;
}
// TODO: Think of a cleaner way to do this, e.g. reference.
MXS_CONFIG_PARAMETER empty;
if (!params)
{
params = &empty;
}
Service* service = new(std::nothrow) Service(name, router, params);
if (service == nullptr)
@ -193,7 +200,6 @@ Service::Service(const std::string& name,
capabilities = module->module_capabilities;
client_count = 0;
n_dbref = 0;
svc_config_param = NULL;
svc_config_version = 0;
stats.started = time(0);
stats.n_failed_starts = 0;
@ -268,7 +274,7 @@ Service::~Service()
MXS_FREE(tmp);
}
MXS_CONFIG_PARAMETER::free_all(&svc_config_param);
delete svc_config_param;
}
void service_free(Service* service)
@ -1144,25 +1150,24 @@ int service_refresh_users(SERVICE* svc)
void service_add_parameters(Service* service, const MXS_CONFIG_PARAMETER* param)
{
MXS_CONFIG_PARAMETER::set_multiple(&service->svc_config_param, param);
service->svc_config_param->set_multiple(*param);
}
void service_add_parameter(Service* service, const char* key, const char* value)
{
MXS_CONFIG_PARAMETER p;
auto pp = &p;
MXS_CONFIG_PARAMETER::set(&pp, key, value);
p.set(key, value);
service_add_parameters(service, &p);
}
void service_remove_parameter(Service* service, const char* key)
{
MXS_CONFIG_PARAMETER::remove(&service->svc_config_param, key);
service->svc_config_param->remove(key);
}
void service_replace_parameter(Service* service, const char* key, const char* value)
{
MXS_CONFIG_PARAMETER::set(&service->svc_config_param, key, value);
service->svc_config_param->set(key, value);
}
/**

31
server/core/test/test_config.cc
View File

@ -47,8 +47,8 @@ int test_validity()
{MXS_END_MODULE_PARAMS}
};
CONFIG_CONTEXT ctx = {};
ctx.object = (char*)"";
CONFIG_CONTEXT ctx;
ctx.object = MXS_STRDUP("");
/** Int parameter */
TEST(config_param_is_valid(params, "p1", "1", &ctx));
@ -110,8 +110,8 @@ int test_validity()
TEST(!config_param_is_valid(params, "p9", "4711q", &ctx));
/** Service parameter */
CONFIG_CONTEXT svc = {};
svc.object = (char*)"test-service";
CONFIG_CONTEXT svc;
svc.object = MXS_STRDUP("test-service");
ctx.next = &svc;
config_add_param(&svc, "type", "service");
TEST(config_param_is_valid(params, "p7", "test-service", &ctx));
@ -129,7 +129,6 @@ int test_validity()
TEST(!config_param_is_valid(params, "p8", "d", &ctx));
TEST(!config_param_is_valid(params, "p8", "a,d", &ctx));
TEST(!config_param_is_valid(params, "p8", "a,b,c,d", &ctx));
MXS_CONFIG_PARAMETER::free_all(&svc.parameters);
return 0;
}
@ -156,11 +155,11 @@ int test_add_parameter()
};
CONFIG_CONTEXT svc1 = {}, svc2 = {}, ctx = {};
svc1.object = (char*)"my-service";
svc2.object = (char*)"some-service";
CONFIG_CONTEXT svc1, svc2, ctx;
svc1.object = MXS_STRDUP("my-service");
svc2.object = MXS_STRDUP("some-service");
svc2.next = &svc1;
ctx.object = (char*)"";
ctx.object = MXS_STRDUP("");
ctx.next = &svc2;
config_add_param(&svc1, "type", "service");
config_add_param(&svc2, "type", "service");
@ -176,8 +175,7 @@ int test_add_parameter()
TEST(ctx.parameters->get_string("p6") == "/tmp");
TEST(ctx.parameters->get_string("p7") == "my-service");
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
ctx.parameters = NULL;
ctx.parameters->clear();
/** Test custom parameters overriding default values */
config_add_param(&ctx, "p1", "-321");
@ -198,9 +196,6 @@ int test_add_parameter()
TEST(val == 5);
TEST(ctx.parameters->get_string("p6") == "/dev/null");
TEST(ctx.parameters->get_string("p7") == "some-service");
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
MXS_CONFIG_PARAMETER::free_all(&svc1.parameters);
MXS_CONFIG_PARAMETER::free_all(&svc2.parameters);
return 0;
}
@ -214,21 +209,19 @@ int test_required_parameters()
{MXS_END_MODULE_PARAMS}
};
CONFIG_CONTEXT ctx = {};
ctx.object = (char*)"";
CONFIG_CONTEXT ctx;
ctx.object = MXS_STRDUP("");
TEST(missing_required_parameters(params, ctx.parameters, "test"));
config_add_defaults(&ctx, params);
TEST(!missing_required_parameters(params, ctx.parameters, "test"));
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
ctx.parameters = NULL;
ctx.parameters->clear();
config_add_param(&ctx, "p1", "1");
config_add_param(&ctx, "p2", "1");
config_add_param(&ctx, "p3", "1");
TEST(!missing_required_parameters(params, ctx.parameters, "test"));
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
return 0;
}

19
server/core/test/test_server.cc
View File

@ -43,7 +43,7 @@
#include "../server.cc"
#include "../internal/server.hh"
static MXS_CONFIG_PARAMETER* params = nullptr;
static MXS_CONFIG_PARAMETER* params = new MXS_CONFIG_PARAMETER;
/**
* test1 Allocate a server and do lots of other things
@ -96,8 +96,8 @@ bool test_load_config(const char* input, Server* server)
if (duplicate_context_init(&dcontext))
{
CONFIG_CONTEXT ccontext = {};
ccontext.object = (char*)"";
CONFIG_CONTEXT ccontext;
ccontext.object = MXS_STRDUP("");
if (config_load_single_file(input, &dcontext, &ccontext))
{
@ -173,13 +173,12 @@ int main(int argc, char** argv)
set_libdir(MXS_STRDUP_A("../../modules/protocol/HTTPD/"));
load_module("HTTPD", MODULE_PROTOCOL);
MXS_CONFIG_PARAMETER::set_from_list(&params,
{
{"address", "127.0.0.1"},
{"port", "9876"},
{"protocol", "HTTPD"},
{"authenticator", "NullAuthAllow"}
}, config_server_params);
params->set_from_list({
{"address", "127.0.0.1"},
{"port", "9876"},
{"protocol", "HTTPD"},
{"authenticator", "NullAuthAllow"}
}, config_server_params);
int result = 0;
result += test1();

8
server/modules/filter/cache/test/test_cacheoptions.cc vendored
View File

@ -320,10 +320,10 @@ int test(FilterModule& filter_module, const TEST_CASE& tc)
int rv = 1;
auto params = filter_module.create_default_parameters();
MXS_CONFIG_PARAMETER::set(&params, "cache_in_transactions", to_string(tc.cit));
MXS_CONFIG_PARAMETER::set(&params, "debug", "31");
MXS_CONFIG_PARAMETER::set(&params, "cached_data", "shared");
MXS_CONFIG_PARAMETER::set(&params, "selects", "verify_cacheable");
params->set("cache_in_transactions", to_string(tc.cit));
params->set("debug", "31");
params->set("cached_data", "shared");
params->set("selects", "verify_cacheable");
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", params);

4
server/modules/filter/dbfwfilter/test/test_dbfwfilter.cc
View File

@ -817,8 +817,8 @@ int test(FilterModule& filter_module, const FW_TEST& t)
file.write(t.zRules);
auto params = filter_module.create_default_parameters();
MXS_CONFIG_PARAMETER::set(&params, "action", zAction);
MXS_CONFIG_PARAMETER::set(&params, "rules", file.name());
params->set("action", zAction);
params->set("rules", file.name());
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", params);

4
server/modules/filter/test/module.cc
View File

@ -23,13 +23,13 @@ namespace maxscale
MXS_CONFIG_PARAMETER* Module::create_default_parameters() const
{
MXS_CONFIG_PARAMETER* rval = nullptr;
MXS_CONFIG_PARAMETER* rval = new MXS_CONFIG_PARAMETER;
const MXS_MODULE_PARAM* param_definition = m_module.parameters;
while (param_definition->name)
{
if (param_definition->default_value)
{
MXS_CONFIG_PARAMETER::set(&rval, param_definition->name, param_definition->default_value);
rval->set(param_definition->name, param_definition->default_value);
}
++param_definition;
}

2
server/modules/monitor/mariadbmon/mariadbmon.cc
View File

@ -698,7 +698,7 @@ void MariaDBMonitor::assign_new_master(MariaDBServer* new_master)
*/
void MariaDBMonitor::disable_setting(const std::string& setting)
{
MXS_CONFIG_PARAMETER::set(&parameters, setting, "false");
parameters->set(setting, "false");
}
/**

17
server/modules/routing/binlogrouter/blr.cc
View File

@ -799,16 +799,15 @@ static MXS_ROUTER* createInstance(SERVICE* service, MXS_CONFIG_PARAMETER* params
{
// Declared in config.cc and needs to be removed if/when blr is refactored
extern const MXS_MODULE_PARAM config_server_params[];
MXS_CONFIG_PARAMETER* params = nullptr;
MXS_CONFIG_PARAMETER::set_from_list(&params,
{
{"address", "_none_"},
{"port", "3306"},
{"protocol", "mariadbbackend"},
{"authenticator", "MySQLBackendAuth"}
}, config_server_params);
MXS_CONFIG_PARAMETER params;
params.set_from_list({
{"address", "_none_"},
{"port", "3306"},
{"protocol", "mariadbbackend"},
{"authenticator", "MySQLBackendAuth"}
}, config_server_params);
Server* server = Server::server_alloc("binlog_router_master_host", params);
Server* server = Server::server_alloc("binlog_router_master_host", &params);
if (server == NULL)
{

19
server/modules/routing/binlogrouter/test/testbinlog.cc
View File

@ -133,21 +133,20 @@ int main(int argc, char** argv)
return 1;
}
MXS_CONFIG_PARAMETER::free_all(&ctx.parameters);
delete ctx.parameters;
// Declared in config.cc and needs to be removed if/when blr is refactored
extern const MXS_MODULE_PARAM config_server_params[];
MXS_CONFIG_PARAMETER* params = nullptr;
MXS_CONFIG_PARAMETER::set_from_list(&params,
{
{"address", "_none_"},
{"port", "3306"},
{"protocol", "MySQLBackend"},
{"authenticator", "MySQLBackendAuth"}
}, config_server_params);
MXS_CONFIG_PARAMETER params;
params.set_from_list({
{"address", "_none_"},
{"port", "3306"},
{"protocol", "MySQLBackend"},
{"authenticator", "MySQLBackendAuth"}
}, config_server_params);
Server* server = Server::server_alloc("binlog_router_master_host", params);
Server* server = Server::server_alloc("binlog_router_master_host", &params);
if (server == NULL)
{
printf("Failed to allocate 'server' object\n");