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

Remove filter options

Browse Source 
None of the filters used the options. The filter API version was already
incremented once for 2.3 so there's no need to increment it again.
This commit is contained in:
Markus Mäkelä 2018-07-10 06:05:50 +03:00
parent cbb8c68770
commit 81527894ee
No known key found for this signature in database
GPG Key ID: 72D48FCE664F7B19
41 changed files with 50 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/examplefilter.cc
View File

@ -50,7 +50,7 @@ ExampleFilter::~ExampleFilter()
}
// static
ExampleFilter* ExampleFilter::create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams)
ExampleFilter* ExampleFilter::create(const char* zName, MXS_CONFIG_PARAMETER* pParams)
{
return new ExampleFilter();
}

2
examples/examplefilter.hh
View File

@ -26,7 +26,7 @@ public:
~ExampleFilter();
// Creates a new filter instance
static ExampleFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static ExampleFilter* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
// Creates a new session for this filter
ExampleFilterSession* newSession(MXS_SESSION* pSession);

4
examples/testfilter.c
View File

@ -29,7 +29,7 @@
* @endverbatim
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -116,7 +116,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
TEST_INSTANCE *my_instance;

3
include/maxscale/filter.h
View File

@ -84,12 +84,11 @@ typedef struct mxs_filter_object
* other API functions.
*
* @param name Name of the filter instance
* @param options Filter options
* @param params Filter parameters
*
* @return New filter instance on NULL on error
*/
MXS_FILTER *(*createInstance)(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
MXS_FILTER *(*createInstance)(const char *name, MXS_CONFIG_PARAMETER *params);
/**
* Called to create a new user session within the filter

4
include/maxscale/filter.hh
View File

@ -228,11 +228,11 @@ template<class FilterType, class FilterSessionType>
class Filter : public MXS_FILTER
{
public:
static MXS_FILTER* createInstance(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams)
static MXS_FILTER* createInstance(const char* zName, MXS_CONFIG_PARAMETER* ppParams)
{
FilterType* pFilter = NULL;
MXS_EXCEPTION_GUARD(pFilter = FilterType::create(zName, pzOptions, ppParams));
MXS_EXCEPTION_GUARD(pFilter = FilterType::create(zName, ppParams));
return pFilter;
}

11
server/core/config.cc
View File

@ -3689,17 +3689,6 @@ int create_new_filter(CONFIG_CONTEXT *obj)
if ((obj->element = filter_alloc(obj->object, module)))
{
MXS_FILTER_DEF* filter_def = (MXS_FILTER_DEF*)obj->element;
char *options = config_get_value(obj->parameters, CN_OPTIONS);
if (options)
{
char *lasts;
char *s = strtok_r(options, ",", &lasts);
while (s)
{
filter_add_option(filter_def, s);
s = strtok_r(NULL, ",", &lasts);
}
}
const MXS_MODULE *mod = get_module(module, MODULE_FILTER);

80
server/core/filter.cc
View File

@ -70,7 +70,6 @@ filter_alloc(const char *name, const char *module)
filter->name = my_name;
filter->module = my_module;
filter->filter = NULL;
filter->options = NULL;
filter->obj = NULL;
filter->parameters = NULL;
@ -122,15 +121,6 @@ filter_free(MXS_FILTER_DEF *filter)
MXS_FREE(filter->name);
MXS_FREE(filter->module);
if (filter->options)
{
for (int i = 0; filter->options[i]; i++)
{
MXS_FREE(filter->options[i]);
}
MXS_FREE(filter->options);
}
filter_free_parameters(filter);
MXS_FREE(filter);
@ -204,15 +194,6 @@ dprintAllFilters(DCB *dcb)
{
dcb_printf(dcb, "Filter %p (%s)\n", ptr, ptr->name);
dcb_printf(dcb, "\tModule: %s\n", ptr->module);
if (ptr->options)
{
dcb_printf(dcb, "\tOptions: ");
for (i = 0; ptr->options && ptr->options[i]; i++)
{
dcb_printf(dcb, "%s ", ptr->options[i]);
}
dcb_printf(dcb, "\n");
}
if (ptr->obj && ptr->filter)
{
ptr->obj->diagnostics(ptr->filter, NULL, dcb);
@ -239,15 +220,6 @@ dprintFilter(DCB *dcb, const MXS_FILTER_DEF *filter)
dcb_printf(dcb, "Filter %p (%s)\n", filter, filter->name);
dcb_printf(dcb, "\tModule: %s\n", filter->module);
if (filter->options)
{
dcb_printf(dcb, "\tOptions: ");
for (i = 0; filter->options && filter->options[i]; i++)
{
dcb_printf(dcb, "%s ", filter->options[i]);
}
dcb_printf(dcb, "\n");
}
if (filter->obj && filter->filter)
{
filter->obj->diagnostics(filter->filter, NULL, dcb);
@ -278,10 +250,6 @@ dListFilters(DCB *dcb)
{
dcb_printf(dcb, "%-19s | %-15s | ",
ptr->name, ptr->module);
for (i = 0; ptr->options && ptr->options[i]; i++)
{
dcb_printf(dcb, "%s ", ptr->options[i]);
}
dcb_printf(dcb, "\n");
ptr = ptr->next;
}
@ -293,41 +261,6 @@ dListFilters(DCB *dcb)
spinlock_release(&filter_spin);
}
/**
* Add a router option to a service
*
* @param filter The filter to add the option to
* @param option The option string
*/
void
filter_add_option(MXS_FILTER_DEF *filter, const char *option)
{
int i;
spinlock_acquire(&filter->spin);
if (filter->options == NULL)
{
filter->options = (char **)MXS_CALLOC(2, sizeof(char *));
MXS_ABORT_IF_NULL(filter->options);
filter->options[0] = MXS_STRDUP_A(option);
filter->options[1] = NULL;
}
else
{
for (i = 0; filter->options[i]; i++)
{
;
}
filter->options = (char **)MXS_REALLOC(filter->options, (i + 2) * sizeof(char *));
MXS_ABORT_IF_NULL(filter->options);
filter->options[i] = MXS_STRDUP_A(option);
MXS_ABORT_IF_NULL(filter->options[i]);
filter->options[i + 1] = NULL;
}
spinlock_release(&filter->spin);
}
/**
* Add a router parameter to a service
*
@ -386,7 +319,6 @@ bool filter_load(MXS_FILTER_DEF* filter)
ss_dassert(!filter->filter);
if ((filter->filter = (filter->obj->createInstance)(filter->name,
filter->options,
filter->parameters)))
{
rval = true;
@ -479,18 +411,6 @@ json_t* filter_parameters_to_json(const MXS_FILTER_DEF* filter)
{
json_t* rval = json_object();
if (filter->options)
{
json_t* arr = json_array();
for (int i = 0; filter->options && filter->options[i]; i++)
{
json_array_append_new(arr, json_string(filter->options[i]));
}
json_object_set_new(rval, "options", arr);
}
/** Add custom module parameters */
const MXS_MODULE* mod = get_module(filter->module, MODULE_FILTER);
config_add_module_params_json(mod, filter->parameters, config_filter_params, rval);

2
server/core/internal/filter.h
View File

@ -29,7 +29,6 @@ struct mxs_filter_def
{
char *name; /**< The Filter name */
char *module; /**< The module to load */
char **options; /**< The options set for this filter */
MXS_CONFIG_PARAMETER *parameters; /**< The filter parameters */
MXS_FILTER* filter; /**< The runtime filter */
MXS_FILTER_OBJECT *obj; /**< The "MODULE_OBJECT" for the filter */
@ -37,7 +36,6 @@ struct mxs_filter_def
struct mxs_filter_def *next; /**< Next filter in the chain of all filters */
};
void filter_add_option(MXS_FILTER_DEF *filter_def, const char *option);
void filter_add_parameter(MXS_FILTER_DEF *filter_def, const char *name, const char *value);
MXS_FILTER_DEF *filter_alloc(const char *name, const char *module_name);
MXS_DOWNSTREAM *filter_apply(MXS_FILTER_DEF *filter_def, MXS_SESSION *session, MXS_DOWNSTREAM *downstream);

3
server/core/test/test_filter.cc
View File

@ -83,9 +83,6 @@ test2()
fprintf(stderr, "filter_alloc: test 1 failed.\n");
return 1;
}
filter_add_option(f1, "option1");
filter_add_option(f1, "option2");
filter_add_option(f1, "option3");
filter_add_parameter(f1, "name1", "value1");
filter_add_parameter(f1, "name2", "value2");
filter_add_parameter(f1, "name3", "value3");

1
server/modules/filter/binlogfilter/binlogfilter.cc
View File

@ -56,7 +56,6 @@ BinlogFilter::~BinlogFilter()
// static: filter create routine
BinlogFilter* BinlogFilter::create(const char* zName,
char** pzOptions,
MXS_CONFIG_PARAMETER* pParams)
{
return new BinlogFilter(pParams);

1
server/modules/filter/binlogfilter/binlogfilter.hh
View File

@ -49,7 +49,6 @@ public:
// Creates a new filter instance
static BinlogFilter* create(const char* zName,
char** pzOptions,
MXS_CONFIG_PARAMETER* ppParams);
// Creates a new session for this filter

6
server/modules/filter/cache/cachefilter.cc vendored
View File

@ -273,7 +273,7 @@ CacheFilter::~CacheFilter()
}
// static
CacheFilter* CacheFilter::create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams)
CacheFilter* CacheFilter::create(const char* zName, MXS_CONFIG_PARAMETER* ppParams)
{
CacheFilter* pFilter = new CacheFilter;
@ -281,7 +281,7 @@ CacheFilter* CacheFilter::create(const char* zName, char** pzOptions, MXS_CONFIG
{
Cache* pCache = NULL;
if (process_params(pzOptions, ppParams, pFilter->m_config))
if (process_params(ppParams, pFilter->m_config))
{
switch (pFilter->m_config.thread_model)
{
@ -338,7 +338,7 @@ uint64_t CacheFilter::getCapabilities()
}
// static
bool CacheFilter::process_params(char **pzOptions, MXS_CONFIG_PARAMETER *ppParams, CACHE_CONFIG& config)
bool CacheFilter::process_params(MXS_CONFIG_PARAMETER *ppParams, CACHE_CONFIG& config)
{
bool error = false;

4
server/modules/filter/cache/cachefilter.hh vendored
View File

@ -22,7 +22,7 @@ class CacheFilter : public maxscale::Filter<CacheFilter, CacheFilterSession>
public:
~CacheFilter();
static CacheFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static CacheFilter* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
Cache& cache()
{
@ -48,7 +48,7 @@ private:
CacheFilter(const CacheFilter&);
CacheFilter& operator = (const CacheFilter&);
static bool process_params(char **pzOptions, MXS_CONFIG_PARAMETER *ppParams, CACHE_CONFIG& config);
static bool process_params(MXS_CONFIG_PARAMETER *ppParams, CACHE_CONFIG& config);
private:
CACHE_CONFIG m_config;

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

@ -320,7 +320,7 @@ int test(FilterModule& filter_module, const TEST_CASE& tc)
sParameters->set_value("cached_data", "shared");
sParameters->set_value("selects", "verify_cacheable");
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", NULL, sParameters);
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", sParameters);
if (sInstance.get())
{

4
server/modules/filter/ccrfilter/ccrfilter.cc
View File

@ -51,7 +51,7 @@
* @endverbatim
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -193,7 +193,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
CCR_INSTANCE *my_instance = static_cast<CCR_INSTANCE*>(MXS_CALLOC(1, sizeof(CCR_INSTANCE)));

2
server/modules/filter/comment/commentfilter.cc
View File

@ -60,7 +60,7 @@ CommentFilter::~CommentFilter()
}
// static
CommentFilter* CommentFilter::create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams)
CommentFilter* CommentFilter::create(const char* zName, MXS_CONFIG_PARAMETER* pParams)
{
return new CommentFilter(config_get_string(pParams, CN_INJECT));
}

2
server/modules/filter/comment/commentfilter.hh
View File

@ -27,7 +27,7 @@ public:
~CommentFilter();
// Creates a new filter instance
static CommentFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static CommentFilter* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
// Creates a new session for this filter
CommentFilterSession* newSession(MXS_SESSION* pSession);

2
server/modules/filter/dbfwfilter/dbfwfilter.cc
View File

@ -1198,7 +1198,7 @@ Dbfw::~Dbfw()
}
Dbfw* Dbfw::create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams)
Dbfw* Dbfw::create(const char* zName, MXS_CONFIG_PARAMETER* pParams)
{
Dbfw* rval = NULL;
RuleList rules;

2
server/modules/filter/dbfwfilter/dbfwfilter.hh
View File

@ -205,7 +205,7 @@ public:
*
* @return New instance or NULL on error
*/
static Dbfw* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static Dbfw* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
/**
* Create a new filter session

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

@ -819,7 +819,7 @@ int test(FilterModule& filter_module, const FW_TEST& t)
sParameters->set_value("action", zAction);
sParameters->set_value("rules", file.name());
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", NULL, sParameters);
auto_ptr<FilterModule::Instance> sInstance = filter_module.createInstance("test", sParameters);
if (sInstance.get())
{

4
server/modules/filter/hintfilter/hintfilter.cc
View File

@ -26,7 +26,7 @@
*
*/
static MXS_FILTER *createInstance(const char* name, char **options, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER *createInstance(const char* name, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -99,7 +99,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
HINT_INSTANCE *my_instance;

4
server/modules/filter/insertstream/insertstream.cc
View File

@ -30,7 +30,7 @@
* @file datastream.c - Streaming of bulk inserts
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER*params);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER*params);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -163,7 +163,7 @@ static const char load_data_template[] = "LOAD DATA LOCAL INFILE 'maxscale.data'
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
DS_INSTANCE *my_instance;

4
server/modules/filter/luafilter/luafilter.cc
View File

@ -55,7 +55,7 @@
/*
* The filter entry points
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -246,7 +246,7 @@ void expose_functions(lua_State* state, GWBUF** active_buffer)
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
LUA_INSTANCE *my_instance;

2
server/modules/filter/masking/maskingfilter.cc
View File

@ -132,7 +132,7 @@ MaskingFilter::~MaskingFilter()
}
// static
MaskingFilter* MaskingFilter::create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams)
MaskingFilter* MaskingFilter::create(const char* zName, MXS_CONFIG_PARAMETER* pParams)
{
MaskingFilter* pFilter = NULL;

2
server/modules/filter/masking/maskingfilter.hh
View File

@ -29,7 +29,7 @@ public:
typedef MaskingFilterConfig Config;
~MaskingFilter();
static MaskingFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static MaskingFilter* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
MaskingFilterSession* newSession(MXS_SESSION* pSession);

8
server/modules/filter/maxrows/maxrows.cc
View File

@ -37,9 +37,7 @@
#include "maxrows.h"
static MXS_FILTER *createInstance(const char *name,
char **options,
MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance,
MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance,
@ -234,9 +232,7 @@ static int send_maxrows_reply_limit(MAXROWS_SESSION_DATA *csdata);
*
* @return The instance data for this new instance
*/
static MXS_FILTER *createInstance(const char *name,
char **options,
MXS_CONFIG_PARAMETER *params)
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
MAXROWS_INSTANCE *cinstance = static_cast<MAXROWS_INSTANCE*>(MXS_CALLOC(1, sizeof(MAXROWS_INSTANCE)));

4
server/modules/filter/mqfilter/mqfilter.cc
View File

@ -85,7 +85,7 @@ static int hktask_id = 0;
/*
* The filter entry points
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -526,7 +526,7 @@ char** parse_optstr(const char* str, const char* tok, int* szstore)
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
MQ_INSTANCE *my_instance = static_cast<MQ_INSTANCE*>(MXS_CALLOC(1, sizeof(MQ_INSTANCE)));

2
server/modules/filter/namedserverfilter/namedserverfilter.cc
View File

@ -232,7 +232,7 @@ uint64_t RegexHintFilter::getCapabilities()
* @return The new instance or null on error
*/
RegexHintFilter*
RegexHintFilter::create(const char* name, char** options, MXS_CONFIG_PARAMETER* params)
RegexHintFilter::create(const char* name, MXS_CONFIG_PARAMETER* params)
{
bool error = false;
SourceHost* source_host = NULL;

3
server/modules/filter/namedserverfilter/namedserverfilter.hh
View File

@ -54,8 +54,7 @@ public:
RegexHintFilter(string user, SourceHost* source, const MappingArray& map,
int ovector_size);
~RegexHintFilter();
static RegexHintFilter* create(const char* zName, char** pzOptions,
MXS_CONFIG_PARAMETER* ppParams);
static RegexHintFilter* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
RegexHintFSession* newSession(MXS_SESSION *session);
void diagnostics(DCB* dcb);
json_t* diagnostics_json() const;

2
server/modules/filter/nullfilter/nullfilter.cc
View File

@ -126,7 +126,7 @@ NullFilter::~NullFilter()
}
// static
NullFilter* NullFilter::create(const char* zName, char**, MXS_CONFIG_PARAMETER* pParams)
NullFilter* NullFilter::create(const char* zName, MXS_CONFIG_PARAMETER* pParams)
{
NullFilter* pFilter = NULL;

2
server/modules/filter/nullfilter/nullfilter.hh
View File

@ -20,7 +20,7 @@ class NullFilter : public maxscale::Filter<NullFilter, NullFilterSession>
{
public:
~NullFilter();
static NullFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams);
static NullFilter* create(const char* zName, MXS_CONFIG_PARAMETER* pParams);
NullFilterSession* newSession(MXS_SESSION* pSession);

4
server/modules/filter/qlafilter/qlafilter.cc
View File

@ -89,7 +89,7 @@ enum log_options
};
/* The filter entry points */
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -442,7 +442,7 @@ MXS_END_DECLS
* @return The new filter instance, or NULL on error
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
bool error = false;
QlaInstance* my_instance = NULL;

4
server/modules/filter/regexfilter/regexfilter.cc
View File

@ -42,7 +42,7 @@
* @endverbatim
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *params);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -188,7 +188,7 @@ void free_instance(REGEX_INSTANCE *instance)
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
REGEX_INSTANCE *my_instance = static_cast<REGEX_INSTANCE*>(MXS_CALLOC(1, sizeof(REGEX_INSTANCE)));

2
server/modules/filter/tee/tee.cc
View File

@ -59,7 +59,7 @@ Tee::Tee(SERVICE* service, std::string user, std::string remote,
*
* @return The instance data for this new instance
*/
Tee* Tee::create(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
Tee* Tee::create(const char *name, MXS_CONFIG_PARAMETER *params)
{
SERVICE* service = config_get_service(params, "service");
const char* source = config_get_string(params, "source");

2
server/modules/filter/tee/tee.hh
View File

@ -32,7 +32,7 @@ class Tee: public mxs::Filter<Tee, TeeSession>
const Tee& operator=(const Tee&);
public:
static Tee* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* ppParams);
static Tee* create(const char* zName, MXS_CONFIG_PARAMETER* ppParams);
TeeSession* newSession(MXS_SESSION* session);
void diagnostics(DCB* pDcb);
json_t* diagnostics_json() const;

6
server/modules/filter/test/filtermodule.cc
View File

@ -27,12 +27,11 @@ namespace maxscale
const char* FilterModule::zName = MODULE_FILTER;
auto_ptr<FilterModule::Instance> FilterModule::createInstance(const char* zName,
char** pzOptions,
MXS_CONFIG_PARAMETER* pParameters)
{
auto_ptr<Instance> sInstance;
MXS_FILTER* pFilter = m_pApi->createInstance(zName, pzOptions, pParameters);
MXS_FILTER* pFilter = m_pApi->createInstance(zName, pParameters);
if (pFilter)
{
@ -43,10 +42,9 @@ auto_ptr<FilterModule::Instance> FilterModule::createInstance(const char* zName,
}
auto_ptr<FilterModule::Instance> FilterModule::createInstance(const char* zName,
char** pzOptions,
std::auto_ptr<ConfigParameters> sParameters)
{
return createInstance(zName, pzOptions, sParameters.get());
return createInstance(zName, sParameters.get());
}
//

2
server/modules/filter/test/maxscale/filtermodule.hh
View File

@ -137,11 +137,9 @@ public:
* @return A new instance or NULL if creation failed.
*/
std::auto_ptr<Instance> createInstance(const char* zName,
char** pzOptions,
MXS_CONFIG_PARAMETER* pParameters);
std::auto_ptr<Instance> createInstance(const char* zName,
char** pzOptions,
std::auto_ptr<ConfigParameters> sParameters);
private:

2
server/modules/filter/throttlefilter/throttlefilter.cc
View File

@ -61,7 +61,7 @@ ThrottleFilter::ThrottleFilter(const ThrottleConfig &config) : m_config(config)
{
}
ThrottleFilter * ThrottleFilter::create(const char* zName, char * * pzOptions, MXS_CONFIG_PARAMETER * pParams)
ThrottleFilter * ThrottleFilter::create(const char* zName, MXS_CONFIG_PARAMETER * pParams)
{
int max_qps = config_get_integer(pParams, MAX_QPS_CFG);
int sample_msecs = config_get_integer(pParams, SAMPLING_DURATION_CFG);

2
server/modules/filter/throttlefilter/throttlefilter.hh
View File

@ -49,7 +49,7 @@ struct ThrottleConfig
class ThrottleFilter : public maxscale::Filter<ThrottleFilter, ThrottleSession>
{
public:
static ThrottleFilter* create(const char* zName, char** pzOptions, MXS_CONFIG_PARAMETER* pParams);
static ThrottleFilter* create(const char* zName, MXS_CONFIG_PARAMETER* pParams);
ThrottleFilter(const ThrottleFilter&) = delete;
ThrottleFilter& operator = (const ThrottleFilter&) = delete;

4
server/modules/filter/topfilter/topfilter.cc
View File

@ -50,7 +50,7 @@
/*
* The filter entry points
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -202,7 +202,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
TOPN_INSTANCE *my_instance = (TOPN_INSTANCE*)MXS_MALLOC(sizeof(TOPN_INSTANCE));

4
server/modules/filter/tpmfilter/tpmfilter.cc
View File

@ -78,7 +78,7 @@ static const int default_sql_size = 4 * 1024;
/*
* The filter entry points
*/
static MXS_FILTER *createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *);
static MXS_FILTER *createInstance(const char *name, MXS_CONFIG_PARAMETER *);
static MXS_FILTER_SESSION *newSession(MXS_FILTER *instance, MXS_SESSION *session);
static void closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
static void freeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session);
@ -208,7 +208,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
* @return The instance data for this new instance
*/
static MXS_FILTER *
createInstance(const char *name, char **options, MXS_CONFIG_PARAMETER *params)
createInstance(const char *name, MXS_CONFIG_PARAMETER *params)
{
TPM_INSTANCE *my_instance = static_cast<TPM_INSTANCE*>(MXS_CALLOC(1, sizeof(TPM_INSTANCE)));