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

Rename FILTER_DEF to MXS_FILTER_DEF

Browse Source 
Provide functions that allows the actual definition of MXS_FILTER_DEF
to be made private.
This commit is contained in:
Johan Wikman
2017-01-13 14:30:11 +02:00
parent affec5e388
commit 265e5c0593
14 changed files with 101 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
include/maxscale/filter.h
View File

@ -92,7 +92,7 @@ typedef struct mxs_filter_object
* This is basically the link between a plugin to load and the
* optons to pass to that plugin.
*/
typedef struct filter_def
typedef struct mxs_filter_def
{
char *name; /**< The Filter name */
char *module; /**< The module to load */
@ -101,13 +101,37 @@ typedef struct filter_def
MXS_FILTER* filter; /**< The runtime filter */
MXS_FILTER_OBJECT *obj; /**< The "MODULE_OBJECT" for the filter */
SPINLOCK spin; /**< Spinlock to protect the filter definition */
struct filter_def *next; /**< Next filter in the chain of all filters */
} FILTER_DEF;
struct mxs_filter_def *next; /**< Next filter in the chain of all filters */
} MXS_FILTER_DEF;
FILTER_DEF *filter_find(const char *);
/**
* Lookup a filter definition using the unique section name in
* the configuration file.
*
* @param name The name of a filter.
*
* @return A filter definition or NULL if not found.
*/
MXS_FILTER_DEF *filter_def_find(const char *name);
/**
* Get module name of a filter definition.
*
* @param filter_def A filter definition.
*
* @return The module name.
*/
const char* filter_def_get_module_name(const MXS_FILTER_DEF* filter_def);
/**
* Get the filter instance of a particular filter definition.
*
* @return A filter instance.
*/
MXS_FILTER* filter_def_get_instance(const MXS_FILTER_DEF* filter_def);
void dprintAllFilters(DCB *);
void dprintFilter(DCB *, const FILTER_DEF *);
void dprintFilter(DCB *, const MXS_FILTER_DEF *);
void dListFilters(DCB *);
/**

2
include/maxscale/modulecmd.h
View File

@ -90,7 +90,7 @@ struct arg_node
SESSION *session;
DCB *dcb;
MONITOR *monitor;
FILTER_DEF *filter;
MXS_FILTER_DEF *filter;
} value;
};

2
include/maxscale/service.h
View File

@ -163,7 +163,7 @@ typedef struct service
* when querying them from the server. MySQL Workbench seems
* to escape at least the underscore character. */
SERVICE_REFRESH_RATE rate_limit; /**< The refresh rate limit for users table */
FILTER_DEF **filters; /**< Ordered list of filters */
MXS_FILTER_DEF **filters; /**< Ordered list of filters */
int n_filters; /**< Number of filters */
long conn_idle_timeout; /**< Session timeout in seconds */
char *weightby; /**< Service weighting parameter name */

4
include/maxscale/session.h
View File

@ -45,7 +45,7 @@ MXS_BEGIN_DECLS
struct dcb;
struct service;
struct filter_def;
struct mxs_filter_def;
struct server;
/**
@ -132,7 +132,7 @@ typedef struct mxs_upstream
*/
typedef struct
{
struct filter_def *filter;
struct mxs_filter_def *filter;
void *instance;
void *session;
} SESSION_FILTER;

53
server/core/filter.c
View File

@ -34,9 +34,9 @@
#include <maxscale/alloc.h>
static SPINLOCK filter_spin = SPINLOCK_INIT; /**< Protects the list of all filters */
static FILTER_DEF *allFilters = NULL; /**< The list of all filters */
static MXS_FILTER_DEF *allFilters = NULL; /**< The list of all filters */
static void filter_free_parameters(FILTER_DEF *filter);
static void filter_free_parameters(MXS_FILTER_DEF *filter);
/**
* Allocate a new filter within MaxScale
@ -47,13 +47,13 @@ static void filter_free_parameters(FILTER_DEF *filter);
*
* @return The newly created filter or NULL if an error occured
*/
FILTER_DEF *
MXS_FILTER_DEF *
filter_alloc(const char *name, const char *module)
{
char* my_name = MXS_STRDUP(name);
char* my_module = MXS_STRDUP(module);
FILTER_DEF *filter = (FILTER_DEF *)MXS_MALLOC(sizeof(FILTER_DEF));
MXS_FILTER_DEF *filter = (MXS_FILTER_DEF *)MXS_MALLOC(sizeof(MXS_FILTER_DEF));
if (!my_name || !my_module || !filter)
{
@ -87,9 +87,9 @@ filter_alloc(const char *name, const char *module)
* @return Returns true if the server was freed
*/
void
filter_free(FILTER_DEF *filter)
filter_free(MXS_FILTER_DEF *filter)
{
FILTER_DEF *ptr;
MXS_FILTER_DEF *ptr;
if (filter)
{
@ -132,17 +132,10 @@ filter_free(FILTER_DEF *filter)
}
}
/**
* Find an existing filter using the unique section name in
* configuration file
*
* @param name The filter name
* @return The server or NULL if not found
*/
FILTER_DEF *
filter_find(const char *name)
MXS_FILTER_DEF *
filter_def_find(const char *name)
{
FILTER_DEF *filter;
MXS_FILTER_DEF *filter;
spinlock_acquire(&filter_spin);
filter = allFilters;
@ -158,6 +151,16 @@ filter_find(const char *name)
return filter;
}
const char* filter_def_get_module_name(const MXS_FILTER_DEF* filter_def)
{
return filter_def->module;
}
MXS_FILTER* filter_def_get_instance(const MXS_FILTER_DEF* filter_def)
{
return filter_def->filter;
}
/**
* Check a parameter to see if it is a standard filter parameter
*
@ -182,7 +185,7 @@ filter_standard_parameter(const char *name)
void
dprintAllFilters(DCB *dcb)
{
FILTER_DEF *ptr;
MXS_FILTER_DEF *ptr;
int i;
spinlock_acquire(&filter_spin);
@ -220,7 +223,7 @@ dprintAllFilters(DCB *dcb)
* to display all active filters in MaxScale
*/
void
dprintFilter(DCB *dcb, const FILTER_DEF *filter)
dprintFilter(DCB *dcb, const MXS_FILTER_DEF *filter)
{
int i;
@ -248,7 +251,7 @@ dprintFilter(DCB *dcb, const FILTER_DEF *filter)
void
dListFilters(DCB *dcb)
{
FILTER_DEF *ptr;
MXS_FILTER_DEF *ptr;
int i;
spinlock_acquire(&filter_spin);
@ -287,7 +290,7 @@ dListFilters(DCB *dcb)
* @param option The option string
*/
void
filter_add_option(FILTER_DEF *filter, const char *option)
filter_add_option(MXS_FILTER_DEF *filter, const char *option)
{
int i;
@ -323,7 +326,7 @@ filter_add_option(FILTER_DEF *filter, const char *option)
* @param value The parameter value
*/
void
filter_add_parameter(FILTER_DEF *filter, const char *name, const char *value)
filter_add_parameter(MXS_FILTER_DEF *filter, const char *name, const char *value)
{
CONFIG_CONTEXT ctx = {.object = ""};
@ -336,7 +339,7 @@ filter_add_parameter(FILTER_DEF *filter, const char *name, const char *value)
* Free filter parameters
* @param filter Filter whose parameters are to be freed
*/
static void filter_free_parameters(FILTER_DEF *filter)
static void filter_free_parameters(MXS_FILTER_DEF *filter)
{
config_parameter_free(filter->parameters);
}
@ -346,7 +349,7 @@ static void filter_free_parameters(FILTER_DEF *filter)
* @param filter Filter definition
* @return True if module was successfully loaded, false if an error occurred
*/
bool filter_load(FILTER_DEF* filter)
bool filter_load(MXS_FILTER_DEF* filter)
{
bool rval = false;
if (filter)
@ -400,7 +403,7 @@ bool filter_load(FILTER_DEF* filter)
* if the filter could not be created
*/
MXS_DOWNSTREAM *
filter_apply(FILTER_DEF *filter, SESSION *session, MXS_DOWNSTREAM *downstream)
filter_apply(MXS_FILTER_DEF *filter, SESSION *session, MXS_DOWNSTREAM *downstream)
{
MXS_DOWNSTREAM *me;
@ -435,7 +438,7 @@ filter_apply(FILTER_DEF *filter, SESSION *session, MXS_DOWNSTREAM *downstream)
* @return The upstream component for the next filter
*/
MXS_UPSTREAM *
filter_upstream(FILTER_DEF *filter, void *fsession, MXS_UPSTREAM *upstream)
filter_upstream(MXS_FILTER_DEF *filter, void *fsession, MXS_UPSTREAM *upstream)
{
MXS_UPSTREAM *me = NULL;

14
server/core/maxscale/filter.h
View File

@ -20,13 +20,13 @@
MXS_BEGIN_DECLS
void filter_add_option(FILTER_DEF *filter_def, const char *option);
void filter_add_parameter(FILTER_DEF *filter_def, const char *name, const char *value);
FILTER_DEF *filter_alloc(const char *name, const char *module_name);
MXS_DOWNSTREAM *filter_apply(FILTER_DEF *filter_def, SESSION *session, MXS_DOWNSTREAM *downstream);
void filter_free(FILTER_DEF *filter_def);
bool filter_load(FILTER_DEF *filter_def);
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, SESSION *session, MXS_DOWNSTREAM *downstream);
void filter_free(MXS_FILTER_DEF *filter_def);
bool filter_load(MXS_FILTER_DEF *filter_def);
int filter_standard_parameter(const char *name);
MXS_UPSTREAM *filter_upstream(FILTER_DEF *filter_def, void *fsession, MXS_UPSTREAM *upstream);
MXS_UPSTREAM *filter_upstream(MXS_FILTER_DEF *filter_def, void *fsession, MXS_UPSTREAM *upstream);
MXS_END_DECLS

2
server/core/modulecmd.c
View File

@ -303,7 +303,7 @@ static bool process_argument(modulecmd_arg_type_t *type, const void* value,
break;
case MODULECMD_ARG_FILTER:
if ((arg->value.filter = filter_find((char*)value)))
if ((arg->value.filter = filter_def_find((char*)value)))
{
arg->type.type = MODULECMD_ARG_FILTER;
rval = true;

14
server/core/service.c
View File

@ -1205,13 +1205,13 @@ void serviceSetRetryOnFailure(SERVICE *service, char* value)
bool
serviceSetFilters(SERVICE *service, char *filters)
{
FILTER_DEF **flist;
MXS_FILTER_DEF **flist;
char *ptr, *brkt;
int n = 0;
bool rval = true;
uint64_t capabilities = 0;
if ((flist = (FILTER_DEF **) MXS_MALLOC(sizeof(FILTER_DEF *))) == NULL)
if ((flist = (MXS_FILTER_DEF **) MXS_MALLOC(sizeof(MXS_FILTER_DEF *))) == NULL)
{
return false;
}
@ -1219,9 +1219,9 @@ serviceSetFilters(SERVICE *service, char *filters)
while (ptr)
{
n++;
FILTER_DEF **tmp;
if ((tmp = (FILTER_DEF **) MXS_REALLOC(flist,
(n + 1) * sizeof(FILTER_DEF *))) == NULL)
MXS_FILTER_DEF **tmp;
if ((tmp = (MXS_FILTER_DEF **) MXS_REALLOC(flist,
(n + 1) * sizeof(MXS_FILTER_DEF *))) == NULL)
{
rval = false;
break;
@ -1230,7 +1230,7 @@ serviceSetFilters(SERVICE *service, char *filters)
flist = tmp;
char *filter_name = trim(ptr);
if ((flist[n - 1] = filter_find(filter_name)))
if ((flist[n - 1] = filter_def_find(filter_name)))
{
if (filter_load(flist[n - 1]))
{
@ -1852,7 +1852,7 @@ void service_destroy_instances(void)
}
if (svc->n_filters)
{
FILTER_DEF **filters = svc->filters;
MXS_FILTER_DEF **filters = svc->filters;
for (int i = 0; i < svc->n_filters; i++)
{
if (filters[i]->obj->destroyInstance && filters[i]->filter)

26
server/core/test/testfilter.c
View File

@ -43,22 +43,22 @@
static int
test1()
{
FILTER_DEF *f1, *f2;
MXS_FILTER_DEF *f1, *f2;
if ((f1 = filter_alloc("test1", "module")) == NULL)
{
fprintf(stderr, "filter_alloc: test 1 failed.\n");
return 1;
}
if ((f2 = filter_find("test1")) == NULL)
if ((f2 = filter_def_find("test1")) == NULL)
{
fprintf(stderr, "filter_find: test 2 failed.\n");
fprintf(stderr, "filter_def_find: test 2 failed.\n");
return 1;
}
filter_free(f1);
if ((f2 = filter_find("test1")) != NULL)
if ((f2 = filter_def_find("test1")) != NULL)
{
fprintf(stderr, "filter_find: test 3 failed delete.\n");
fprintf(stderr, "filter_def_find: test 3 failed delete.\n");
return 1;
}
@ -76,7 +76,7 @@ test1()
static int
test2()
{
FILTER_DEF *f1;
MXS_FILTER_DEF *f1;
if ((f1 = filter_alloc("test1", "module")) == NULL)
{
@ -100,7 +100,7 @@ test2()
static int
test3()
{
FILTER_DEF *f1;
MXS_FILTER_DEF *f1;
char name[40];
int i, n_filters = 1000;
@ -117,25 +117,25 @@ test3()
for (i = 0; i < n_filters; i++)
{
sprintf(name, "filter%d", i);
if ((f1 = filter_find(name)) == NULL)
if ((f1 = filter_def_find(name)) == NULL)
{
fprintf(stderr, "filter_find: test 3 failed.\n");
fprintf(stderr, "filter_def_find: test 3 failed.\n");
return 1;
}
}
for (i = 0; i < n_filters; i++)
{
sprintf(name, "filter%d", i);
if ((f1 = filter_find(name)) == NULL)
if ((f1 = filter_def_find(name)) == NULL)
{
fprintf(stderr, "filter_find: test 3 failed.\n");
fprintf(stderr, "filter_def_find: test 3 failed.\n");
return 1;
}
filter_free(f1);
if ((f1 = filter_find(name)) != NULL)
if ((f1 = filter_def_find(name)) != NULL)
{
fprintf(stderr,
"filter_find: test 3 failed - found deleted filter.\n");
"filter_def_find: test 3 failed - found deleted filter.\n");
return 1;
}
}

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

@ -91,7 +91,7 @@ bool cache_command_show(const MODULECMD_ARG* pArgs)
DCB* pDcb = pArgs->argv[0].value.dcb;
ss_dassert(pDcb);
const FILTER_DEF* pFilterDef = pArgs->argv[1].value.filter;
const MXS_FILTER_DEF* pFilterDef = pArgs->argv[1].value.filter;
ss_dassert(pFilterDef);
if (strcmp(pFilterDef->module, "cache") == 0)

4
server/modules/filter/dbfwfilter/dbfwfilter.c
View File

@ -683,7 +683,7 @@ TIMERANGE* split_reverse_time(TIMERANGE* tr)
bool dbfw_reload_rules(const MODULECMD_ARG *argv)
{
bool rval = true;
FILTER_DEF *filter = argv->argv[0].value.filter;
MXS_FILTER_DEF *filter = argv->argv[0].value.filter;
FW_INSTANCE *inst = (FW_INSTANCE*)filter->filter;
if (modulecmd_arg_is_present(argv, 1))
@ -748,7 +748,7 @@ bool dbfw_reload_rules(const MODULECMD_ARG *argv)
bool dbfw_show_rules(const MODULECMD_ARG *argv)
{
DCB *dcb = argv->argv[0].value.dcb;
FILTER_DEF *filter = argv->argv[1].value.filter;
MXS_FILTER_DEF *filter = argv->argv[1].value.filter;
FW_INSTANCE *inst = (FW_INSTANCE*)filter->filter;
dcb_printf(dcb, "Rule, Type, Times Matched\n");

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

@ -41,7 +41,7 @@ bool masking_command_reload(const MODULECMD_ARG* pArgs)
DCB* pDcb = pArgs->argv[0].value.dcb;
ss_dassert(pDcb);
const FILTER_DEF* pFilterDef = pArgs->argv[1].value.filter;
const MXS_FILTER_DEF* pFilterDef = pArgs->argv[1].value.filter;
ss_dassert(pFilterDef);
if (strcmp(pFilterDef->module, "masking") == 0)

167
server/modules/filter/masking/test/testprepared.cc
View File

@ -1,167 +0,0 @@
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <mysql.h>
using namespace std;
namespace
{
void print_usage_and_exit(ostream& out, const char* zName)
{
out << "usage: " << zName << "[-h host] [-P port] [-u user] [-p password] -s statement" << endl;
exit(EXIT_FAILURE);
}
int test_prepared(MYSQL* pMysql, const char* zStatement)
{
int rc = EXIT_FAILURE;
MYSQL_STMT* pStmt = mysql_stmt_init(pMysql);
if (pStmt)
{
if (mysql_stmt_prepare(pStmt, zStatement, strlen(zStatement)) == 0)
{
if (mysql_stmt_execute(pStmt) == 0)
{
int nColumns = mysql_stmt_field_count(pStmt);
cout << "Columns: " << nColumns << endl;
typedef char Buffer[256];
Buffer buffers[nColumns];
MYSQL_BIND bind[nColumns];
unsigned long lengths[nColumns];
my_bool nulls[nColumns];
for (int i = 0; i < nColumns; ++i)
{
memset(&bind[i], 0, sizeof(MYSQL_BIND));
bind[i].buffer_type = MYSQL_TYPE_STRING;
bind[i].buffer = buffers[i];
bind[i].buffer_length = 256;
bind[i].length = &lengths[i];
bind[i].is_null = &nulls[i];
}
if (mysql_stmt_bind_result(pStmt, bind) == 0)
{
while (mysql_stmt_fetch(pStmt) == 0)
{
for (int j = 0; j < nColumns; ++j)
{
if (nulls[j])
{
cout << "NULL";
}
else
{
cout.write(buffers[j], lengths[j]);
}
if (j < nColumns - 1)
{
cout << ", ";
}
}
cout << endl;
}
}
else
{
cerr << "error (mysql_stmt_bind_result): " << mysql_stmt_error(pStmt) << endl;
}
}
else
{
cerr << "error (mysql_stmt_execute): " << mysql_stmt_error(pStmt) << endl;
}
}
else
{
cerr << "error (mysql_stmt_prepare): " << mysql_stmt_error(pStmt) << endl;
}
mysql_stmt_close(pStmt);
}
else
{
cerr << "error (mysql_stmt_init): " << mysql_error(pMysql) << endl;
}
return rc;
}
}
int main(int argc, char* argv[])
{
int rc = EXIT_FAILURE;
const char* zHost = "127.0.0.1";
int port = 3306;
const char* zUser = getenv("USER");
const char* zPassword = NULL;
const char* zStatement = NULL;
int opt;
while ((opt = getopt(argc, argv, "h:P:u:p:s:")) != -1)
{
switch (opt)
{
case 'h':
zHost = optarg;
break;
case 'p':
zPassword = optarg;
break;
case 'u':
zUser = optarg;
break;
case 'P':
port = atoi(optarg);
break;
case 's':
zStatement = optarg;
break;
default:
print_usage_and_exit(cerr, argv[0]);
}
}
if (!zStatement)
{
print_usage_and_exit(cerr, argv[0]);
}
MYSQL* pMysql = mysql_init(NULL);
if (pMysql)
{
if (mysql_real_connect(pMysql, zHost, zUser, zPassword, NULL, port, NULL, 0))
{
rc = test_prepared(pMysql, zStatement);
}
else
{
cerr << "error: " << mysql_error(pMysql) << endl;
}
mysql_close(pMysql);
pMysql = NULL;
}
else
{
cerr << "error: " << mysql_error(NULL) << endl;
}
return rc;
}

2
server/modules/routing/debugcli/debugcmd.c
View File

@ -1524,7 +1524,7 @@ convert_arg(char *arg, int arg_type)
break;
case ARG_TYPE_FILTER:
rval = (unsigned long)filter_find(arg);
rval = (unsigned long)filter_def_find(arg);
break;
case ARG_TYPE_NUMERIC: