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

Clean up router.h

Browse Source 
Nothing moved to core, just rename and cleanup.
This commit is contained in:
Esa Korhonen 2017-01-26 15:36:51 +02:00
parent 74225daf46
commit 8b83bf834e
18 changed files with 229 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/maxscale/filter.h
View File

@ -47,7 +47,7 @@ typedef void *MXS_FILTER_SESSION;
/**
* @verbatim
* The "module object" structure for a query router module
* The "module object" structure for a filter module
*
* The entry points are:
* createInstance Called by the service to create a new instance of the filter

69
include/maxscale/router.h
View File

@ -13,41 +13,34 @@
*/
/**
* @file router.h - The query router interface mechanisms
*
* Revision History
*
* Date Who Description
* 14/06/2013 Mark Riddoch Initial implementation
* 26/06/2013 Mark Riddoch Addition of router options and the diagnostic entry point
* 15/07/2013 Massimiliano Pinto Added clientReply entry point
* 16/07/2013 Massimiliano Pinto Added router commands values
* 22/10/2013 Massimiliano Pinto Added router errorReply entry point
* 27/10/2015 Martin Brampton Add RCAP_TYPE_NO_RSESSION
* 08/11/2016 Massimiliano Pinto Add destroyInstance() entry point
*
* @file router.h - The query router public interface definition
*/
#include <maxscale/cdefs.h>
#include <stdint.h>
#include <maxscale/buffer.h>
#include <maxscale/routing.h>
#include <maxscale/service.h>
#include <maxscale/session.h>
#include <maxscale/buffer.h>
#include <stdint.h>
MXS_BEGIN_DECLS
/**
* The ROUTER handle points to module specific data, so the best we can do
* is to make it a void * externally.
* MXS_ROUTER is an opaque type representing a particular router instance.
*
* MaxScale itself does not do anything with it, except for receiving it
* from the @c createInstance function of a router module and subsequently
* passing it back to the API functions of the router.
*/
typedef void *ROUTER;
typedef void *MXS_ROUTER;
typedef enum error_action
{
ERRACT_NEW_CONNECTION = 0x001,
ERRACT_REPLY_CLIENT = 0x002
} error_action_t;
} mxs_error_action_t;
/**
* @verbatim
@ -57,41 +50,45 @@ typedef enum error_action
* createInstance Called by the service to create a new instance of the query router
* newSession Called to create a new user session within the query router
* closeSession Called when a session is closed
* freeSession Called when a session is freed
* routeQuery Called on each query that requires routing
* diagnostics Called to force the router to print diagnostic output
* clientReply Called to reply to client the data from one or all backends
* errorReply Called to reply to client errors with optional closeSession or make a request for
* a new backend connection
* handleError Called to reply to client errors with optional closeSession
* or make a request for a new backend connection
* getCapabilities Called to obtain the capabilities of the router
* destroyInstance Called for destroying a router instance
*
* @endverbatim
*
* @see load_module
*/
typedef struct router_object
typedef struct mxs_router_object
{
ROUTER *(*createInstance)(SERVICE *service, char **options);
void *(*newSession)(ROUTER *instance, MXS_SESSION *session);
void (*closeSession)(ROUTER *instance, void *router_session);
void (*freeSession)(ROUTER *instance, void *router_session);
int32_t (*routeQuery)(ROUTER *instance, void *router_session, GWBUF *queue);
void (*diagnostics)(ROUTER *instance, DCB *dcb);
void (*clientReply)(ROUTER* instance, void* router_session, GWBUF* queue, DCB *backend_dcb);
void (*handleError)(ROUTER* instance,
MXS_ROUTER *(*createInstance)(SERVICE *service, char **options);
void *(*newSession)(MXS_ROUTER *instance, MXS_SESSION *session);
void (*closeSession)(MXS_ROUTER *instance, void *router_session);
void (*freeSession)(MXS_ROUTER *instance, void *router_session);
int32_t (*routeQuery)(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
void (*diagnostics)(MXS_ROUTER *instance, DCB *dcb);
void (*clientReply)(MXS_ROUTER* instance, void* router_session, GWBUF* queue,
DCB *backend_dcb);
void (*handleError)(MXS_ROUTER* instance,
void* router_session,
GWBUF* errmsgbuf,
DCB* backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool* succp);
uint64_t (*getCapabilities)(void);
void (*destroyInstance)(ROUTER *instance);
} ROUTER_OBJECT;
void (*destroyInstance)(MXS_ROUTER *instance);
} MXS_ROUTER_OBJECT;
/**
* The router module API version. Any change that changes the router API
* must update these versions numbers in accordance with the rules in
* modinfo.h.
*/
#define ROUTER_VERSION { 2, 0, 0 }
#define MXS_ROUTER_VERSION { 2, 0, 0 }
/**
* Specifies capabilities specific for routers. Common capabilities
@ -107,13 +104,13 @@ typedef enum router_capability
RCAP_TYPE_NO_RSESSION = 0x00010000, /**< Router does not use router sessions */
RCAP_TYPE_NO_USERS_INIT = 0x00020000, /**< Prevent the loading of authenticator
users when the service is started */
} router_capability_t;
} mxs_router_capability_t;
typedef enum
{
TYPE_UNDEFINED = 0,
TYPE_MASTER,
TYPE_ALL
} target_t;
} mxs_target_t;
MXS_END_DECLS

4
include/maxscale/service.h
View File

@ -59,7 +59,7 @@ MXS_BEGIN_DECLS
struct server;
struct router;
struct router_object;
struct mxs_router_object;
struct users;
/**
@ -145,7 +145,7 @@ typedef struct service
* that this service will listen on */
char *routerModule; /**< Name of router module to use */
char **routerOptions; /**< Router specific option strings */
struct router_object *router; /**< The router we are using */
struct mxs_router_object *router; /**< The router we are using */
void *router_instance; /**< The router instance for this service */
char *version_string; /**< version string for this service listeners */
SERVER_REF *dbref; /**< server references */

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

@ -524,7 +524,7 @@ static void
closeSession(MXS_FILTER *instance, MXS_FILTER_SESSION *session)
{
TEE_SESSION *my_session = (TEE_SESSION *) session;
ROUTER_OBJECT *router;
MXS_ROUTER_OBJECT *router;
void *router_instance, *rsession;
MXS_SESSION *bsession;
#ifdef SS_DEBUG

12
server/modules/protocol/MySQL/MySQLBackend/mysql_backend.c
View File

@ -1122,8 +1122,8 @@ static int gw_error_backend_event(DCB *dcb)
{
MXS_SESSION* session;
void* rsession;
ROUTER_OBJECT* router;
ROUTER* router_instance;
MXS_ROUTER_OBJECT* router;
MXS_ROUTER* router_instance;
GWBUF* errbuf;
bool succp;
mxs_session_state_t ses_state;
@ -1249,8 +1249,8 @@ static int gw_backend_hangup(DCB *dcb)
{
MXS_SESSION* session;
void* rsession;
ROUTER_OBJECT* router;
ROUTER* router_instance;
MXS_ROUTER_OBJECT* router;
MXS_ROUTER* router_instance;
bool succp;
GWBUF* errbuf;
mxs_session_state_t ses_state;
@ -1453,8 +1453,8 @@ static int backend_write_delayqueue(DCB *dcb, GWBUF *buffer)
{
MXS_SESSION *session = dcb->session;
CHK_SESSION(session);
ROUTER_OBJECT *router = session->service->router;
ROUTER *router_instance = session->service->router_instance;
MXS_ROUTER_OBJECT *router = session->service->router;
MXS_ROUTER *router_instance = session->service->router_instance;
void *rsession = session->router_session;
bool succp = false;
GWBUF* errbuf = mysql_create_custom_error(

2
server/modules/protocol/MySQL/MySQLClient/mysql_client.c
View File

@ -1337,7 +1337,7 @@ static int
gw_client_close(DCB *dcb)
{
MXS_SESSION* session;
ROUTER_OBJECT* router;
MXS_ROUTER_OBJECT* router;
void* router_instance;
#if defined(SS_DEBUG)
MySQLProtocol* protocol = (MySQLProtocol *)dcb->protocol;

40
server/modules/routing/avrorouter/avro.c
View File

@ -71,16 +71,16 @@ static const char* alter_table_regex =
"(?i)alter[[:space:]]+table.*column";
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int routeQuery(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static void clientReply(ROUTER *instance, void *router_session, GWBUF *queue,
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static void clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue,
DCB *backend_dcb);
static void errorReply(ROUTER *instance, void *router_session, GWBUF *message,
DCB *backend_dcb, error_action_t action, bool *succp);
static void errorReply(MXS_ROUTER *instance, void *router_session, GWBUF *message,
DCB *backend_dcb, mxs_error_action_t action, bool *succp);
static uint64_t getCapabilities(void);
extern int MaxScaleUptime();
extern void avro_get_used_tables(AVRO_INSTANCE *router, DCB *dcb);
@ -140,7 +140,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
};
modulecmd_register_command(MXS_MODULE_NAME, "convert", avro_handle_convert, 2, args);
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -158,7 +158,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_GA,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"Binlogrouter",
"V1.0.0",
&MyObject,
@ -371,7 +371,7 @@ static void table_map_hfree(void* v)
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
AVRO_INSTANCE *inst;
@ -605,7 +605,7 @@ createInstance(SERVICE *service, char **options)
MXS_INFO("current MySQL binlog file is %s, pos is %lu\n",
inst->binlog_name, inst->current_pos);
return (ROUTER *) inst;
return (MXS_ROUTER *) inst;
}
/**
@ -620,7 +620,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
AVRO_INSTANCE *inst = (AVRO_INSTANCE *) instance;
AVRO_CLIENT *client;
@ -692,7 +692,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param router_cli_ses The particular session to free
*
*/
static void freeSession(ROUTER* router_instance, void* router_client_ses)
static void freeSession(MXS_ROUTER* router_instance, void* router_client_ses)
{
AVRO_INSTANCE *router = (AVRO_INSTANCE *) router_instance;
AVRO_CLIENT *client = (AVRO_CLIENT *) router_client_ses;
@ -741,7 +741,7 @@ static void freeSession(ROUTER* router_instance, void* router_client_ses)
* @param instance The router instance data
* @param router_session The session being closed
*/
static void closeSession(ROUTER *instance, void *router_session)
static void closeSession(MXS_ROUTER *instance, void *router_session)
{
AVRO_INSTANCE *router = (AVRO_INSTANCE *) instance;
AVRO_CLIENT *client = (AVRO_CLIENT *) router_session;
@ -773,7 +773,7 @@ static void closeSession(ROUTER *instance, void *router_session)
* @return 1 on success, 0 on error
*/
static int
routeQuery(ROUTER *instance, void *router_session, GWBUF *queue)
routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue)
{
AVRO_INSTANCE *router = (AVRO_INSTANCE *) instance;
AVRO_CLIENT *client = (AVRO_CLIENT *) router_session;
@ -829,7 +829,7 @@ spin_reporter(void *dcb, char *desc, int value)
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *router, DCB *dcb)
diagnostics(MXS_ROUTER *router, DCB *dcb)
{
AVRO_INSTANCE *router_inst = (AVRO_INSTANCE *) router;
AVRO_CLIENT *session;
@ -949,7 +949,7 @@ diagnostics(ROUTER *router, DCB *dcb)
* @param queue The GWBUF with reply data
*/
static void
clientReply(ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
{
/** We should never end up here */
ss_dassert(false);
@ -991,7 +991,7 @@ extract_message(GWBUF *errpkt)
*
*/
static void
errorReply(ROUTER *instance, void *router_session, GWBUF *message, DCB *backend_dcb, error_action_t action,
errorReply(MXS_ROUTER *instance, void *router_session, GWBUF *message, DCB *backend_dcb, mxs_error_action_t action,
bool *succp)
{
/** We should never end up here */

50
server/modules/routing/binlogrouter/blr.c
View File

@ -88,22 +88,22 @@
#include <maxscale/alloc.h>
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void free_instance(ROUTER_INSTANCE *instance);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int routeQuery(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static void clientReply(ROUTER *instance,
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static void clientReply(MXS_ROUTER *instance,
void *router_session,
GWBUF *queue,
DCB *backend_dcb);
static void errorReply(ROUTER *instance,
static void errorReply(MXS_ROUTER *instance,
void *router_session,
GWBUF *message,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp);
static uint64_t getCapabilities(void);
@ -114,7 +114,7 @@ static int blr_check_binlog(ROUTER_INSTANCE *router);
int blr_read_events_all_events(ROUTER_INSTANCE *router, int fix, int debug);
void blr_master_close(ROUTER_INSTANCE *);
void blr_free_ssl_data(ROUTER_INSTANCE *inst);
static void destroyInstance(ROUTER *instance);
static void destroyInstance(MXS_ROUTER *instance);
bool blr_extract_key(const char *linebuf, int nline, ROUTER_INSTANCE *router);
bool blr_get_encryption_key(ROUTER_INSTANCE *router);
int blr_parse_key_file(ROUTER_INSTANCE *router);
@ -151,7 +151,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -169,7 +169,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_GA,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"Binlogrouter",
"V2.1.0",
&MyObject,
@ -221,7 +221,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
ROUTER_INSTANCE *inst;
@ -893,7 +893,7 @@ createInstance(SERVICE *service, char **options)
MXS_ERROR("The replication from master cannot be started"
" due to errors in current binlog file");
/* Don't start replication, just return */
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
}
@ -915,14 +915,14 @@ createInstance(SERVICE *service, char **options)
inst->m_errmsg = mxs_strdup("HY000 Binlog encryption is Off but binlog file has "
"the START_ENCRYPTION_EVENT");
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
/* Start replication from master server */
blr_start_master(inst);
}
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
static void
@ -961,7 +961,7 @@ free_instance(ROUTER_INSTANCE *instance)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *)instance;
ROUTER_SLAVE *slave;
@ -1029,7 +1029,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param router_cli_ses The particular session to free
*
*/
static void freeSession(ROUTER* router_instance,
static void freeSession(MXS_ROUTER* router_instance,
void* router_client_ses)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)router_instance;
@ -1098,7 +1098,7 @@ static void freeSession(ROUTER* router_instance,
* @param router_session The session being closed
*/
static void
closeSession(ROUTER *instance, void *router_session)
closeSession(MXS_ROUTER *instance, void *router_session)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
ROUTER_SLAVE *slave = (ROUTER_SLAVE *)router_session;
@ -1184,7 +1184,7 @@ closeSession(ROUTER *instance, void *router_session)
* @return The number of bytes sent
*/
static int
routeQuery(ROUTER *instance, void *router_session, GWBUF *queue)
routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
ROUTER_SLAVE *slave = (ROUTER_SLAVE *)router_session;
@ -1240,7 +1240,7 @@ spin_reporter(void *dcb, char *desc, int value)
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *router, DCB *dcb)
diagnostics(MXS_ROUTER *router, DCB *dcb)
{
ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *)router;
ROUTER_SLAVE *session;
@ -1683,7 +1683,7 @@ diagnostics(ROUTER *router, DCB *dcb)
* @param queue The GWBUF with reply data
*/
static void
clientReply(ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
@ -1728,11 +1728,11 @@ extract_message(GWBUF *errpkt)
*
*/
static void
errorReply(ROUTER *instance,
errorReply(MXS_ROUTER *instance,
void *router_session,
GWBUF *message,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
@ -2436,7 +2436,7 @@ blr_free_ssl_data(ROUTER_INSTANCE *inst)
* @param service The service this router instance belongs to
*/
static void
destroyInstance(ROUTER *instance)
destroyInstance(MXS_ROUTER *instance)
{
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *) instance;

30
server/modules/routing/cli/cli.c
View File

@ -43,12 +43,12 @@
#include <maxscale/log_manager.h>
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int execute(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int execute(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static uint64_t getCapabilities(void);
extern int execute_cmd(CLI_SESSION *cli);
@ -70,7 +70,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -88,7 +88,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_GA,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"The admin user interface",
"V1.0.0",
&MyObject,
@ -113,7 +113,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
CLI_INSTANCE *inst;
@ -146,7 +146,7 @@ createInstance(SERVICE *service, char **options)
instances = inst;
spinlock_release(&instlock);
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
/**
@ -157,7 +157,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
CLI_INSTANCE *inst = (CLI_INSTANCE *)instance;
CLI_SESSION *client;
@ -188,7 +188,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param router_session The session being closed
*/
static void
closeSession(ROUTER *instance, void *router_session)
closeSession(MXS_ROUTER *instance, void *router_session)
{
CLI_INSTANCE *inst = (CLI_INSTANCE *)instance;
CLI_SESSION *session = (CLI_SESSION *)router_session;
@ -225,7 +225,7 @@ closeSession(ROUTER *instance, void *router_session)
* @param router_client_session The router session as returned from newSession
*/
static void freeSession(
ROUTER* router_instance,
MXS_ROUTER* router_instance,
void* router_client_session)
{
MXS_FREE(router_client_session);
@ -243,7 +243,7 @@ static void freeSession(
* @return The number of bytes sent
*/
static int
execute(ROUTER *instance, void *router_session, GWBUF *queue)
execute(MXS_ROUTER *instance, void *router_session, GWBUF *queue)
{
CLI_SESSION *session = (CLI_SESSION *)router_session;
@ -283,7 +283,7 @@ execute(ROUTER *instance, void *router_session, GWBUF *queue)
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *instance, DCB *dcb)
diagnostics(MXS_ROUTER *instance, DCB *dcb)
{
return; /* Nothing to do currently */
}

30
server/modules/routing/debugcli/debugcli.c
View File

@ -42,12 +42,12 @@
#include <maxscale/log_manager.h>
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int execute(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int execute(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static uint64_t getCapabilities ();
extern int execute_cmd(CLI_SESSION *cli);
@ -69,7 +69,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -87,7 +87,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_GA,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"The debug user interface",
"V1.1.1",
&MyObject,
@ -112,7 +112,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
CLI_INSTANCE *inst;
@ -137,7 +137,7 @@ createInstance(SERVICE *service, char **options)
instances = inst;
spinlock_release(&instlock);
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
/**
@ -148,7 +148,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
CLI_INSTANCE *inst = (CLI_INSTANCE *)instance;
CLI_SESSION *client;
@ -182,7 +182,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param router_session The session being closed
*/
static void
closeSession(ROUTER *instance, void *router_session)
closeSession(MXS_ROUTER *instance, void *router_session)
{
CLI_INSTANCE *inst = (CLI_INSTANCE *)instance;
CLI_SESSION *session = (CLI_SESSION *)router_session;
@ -219,7 +219,7 @@ closeSession(ROUTER *instance, void *router_session)
* @param router_client_session The router session as returned from newSession
*/
static void freeSession(
ROUTER* router_instance,
MXS_ROUTER* router_instance,
void* router_client_session)
{
MXS_FREE(router_client_session);
@ -237,7 +237,7 @@ static void freeSession(
* @return The number of bytes sent
*/
static int
execute(ROUTER *instance, void *router_session, GWBUF *queue)
execute(MXS_ROUTER *instance, void *router_session, GWBUF *queue)
{
CLI_SESSION *session = (CLI_SESSION *)router_session;
@ -288,7 +288,7 @@ execute(ROUTER *instance, void *router_session, GWBUF *queue)
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *instance, DCB *dcb)
diagnostics(MXS_ROUTER *instance, DCB *dcb)
{
return; /* Nothing to do currently */
}

38
server/modules/routing/maxinfo/maxinfo.c
View File

@ -64,18 +64,18 @@ static int handle_url(INFO_INSTANCE *instance, INFO_SESSION *router_session, GWB
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int execute(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int execute(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static uint64_t getCapabilities(void);
static void handleError(ROUTER *instance,
static void handleError(MXS_ROUTER *instance,
void *router_session,
GWBUF *errbuf,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp);
static SPINLOCK instlock;
@ -95,7 +95,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -113,7 +113,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_ALPHA_RELEASE,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"The MaxScale Information Schema",
"V1.0.0",
&MyObject,
@ -138,7 +138,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
INFO_INSTANCE *inst;
@ -170,7 +170,7 @@ createInstance(SERVICE *service, char **options)
instances = inst;
spinlock_release(&instlock);
return (ROUTER *)inst;
return (MXS_ROUTER *)inst;
}
/**
@ -181,7 +181,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
INFO_INSTANCE *inst = (INFO_INSTANCE *)instance;
INFO_SESSION *client;
@ -212,7 +212,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param router_session The session being closed
*/
static void
closeSession(ROUTER *instance, void *router_session)
closeSession(MXS_ROUTER *instance, void *router_session)
{
INFO_INSTANCE *inst = (INFO_INSTANCE *)instance;
INFO_SESSION *session = (INFO_SESSION *)router_session;
@ -248,7 +248,7 @@ closeSession(ROUTER *instance, void *router_session)
* @param router_instance The router session
* @param router_client_session The router session as returned from newSession
*/
static void freeSession(ROUTER* router_instance,
static void freeSession(MXS_ROUTER* router_instance,
void* router_client_session)
{
MXS_FREE(router_client_session);
@ -268,11 +268,11 @@ static void freeSession(ROUTER* router_instance,
* @param succp Result of action: true iff router can continue
*
*/
static void handleError(ROUTER *instance,
static void handleError(MXS_ROUTER *instance,
void *router_session,
GWBUF *errbuf,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp)
{
@ -321,7 +321,7 @@ static void handleError(ROUTER *instance,
* @return The number of bytes sent
*/
static int
execute(ROUTER *rinstance, void *router_session, GWBUF *queue)
execute(MXS_ROUTER *rinstance, void *router_session, GWBUF *queue)
{
INFO_INSTANCE *instance = (INFO_INSTANCE *)rinstance;
INFO_SESSION *session = (INFO_SESSION *)router_session;
@ -386,7 +386,7 @@ execute(ROUTER *rinstance, void *router_session, GWBUF *queue)
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *instance, DCB *dcb)
diagnostics(MXS_ROUTER *instance, DCB *dcb)
{
return; /* Nothing to do currently */
}

44
server/modules/routing/readconnroute/readconnroute.c
View File

@ -89,16 +89,16 @@
#include <maxscale/modutil.h>
/* The router entry points */
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *router_session);
static void freeSession(ROUTER *instance, void *router_session);
static int routeQuery(ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static void clientReply(ROUTER *instance, void *router_session, GWBUF *queue,
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *router_session);
static void freeSession(MXS_ROUTER *instance, void *router_session);
static int routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static void clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue,
DCB *backend_dcb);
static void handleError(ROUTER *instance, void *router_session, GWBUF *errbuf,
DCB *problem_dcb, error_action_t action, bool *succp);
static void handleError(MXS_ROUTER *instance, void *router_session, GWBUF *errbuf,
DCB *problem_dcb, mxs_error_action_t action, bool *succp);
static uint64_t getCapabilities(void);
static bool rses_begin_locked_router_action(ROUTER_CLIENT_SES* rses);
static void rses_end_locked_router_action(ROUTER_CLIENT_SES* rses);
@ -122,7 +122,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -140,7 +140,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_GA,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"A connection based router to load balance based on connections",
"V1.1.0",
&MyObject,
@ -173,7 +173,7 @@ static inline void free_readconn_instance(ROUTER_INSTANCE *router)
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
ROUTER_INSTANCE *inst;
@ -257,7 +257,7 @@ createInstance(SERVICE *service, char **options)
instances = inst;
spinlock_release(&instlock);
return (ROUTER *) inst;
return (MXS_ROUTER *) inst;
}
/**
@ -268,7 +268,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *) instance;
ROUTER_CLIENT_SES *client_rses;
@ -465,7 +465,7 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @details (write detailed description here)
*
*/
static void freeSession(ROUTER* router_instance, void* router_client_ses)
static void freeSession(MXS_ROUTER* router_instance, void* router_client_ses)
{
ROUTER_INSTANCE* router = (ROUTER_INSTANCE *) router_instance;
ROUTER_CLIENT_SES* router_cli_ses = (ROUTER_CLIENT_SES *) router_client_ses;
@ -484,7 +484,7 @@ static void freeSession(ROUTER* router_instance, void* router_client_ses)
* @param router_session The session being closed
*/
static void
closeSession(ROUTER *instance, void *router_session)
closeSession(MXS_ROUTER *instance, void *router_session)
{
ROUTER_CLIENT_SES *router_cli_ses = (ROUTER_CLIENT_SES *) router_session;
DCB* backend_dcb;
@ -552,7 +552,7 @@ static void log_closed_session(mysql_server_cmd_t mysql_command, bool is_closed,
* @return if succeed 1, otherwise 0
*/
static int
routeQuery(ROUTER *instance, void *router_session, GWBUF *queue)
routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *queue)
{
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *) instance;
ROUTER_CLIENT_SES *router_cli_ses = (ROUTER_CLIENT_SES *) router_session;
@ -631,7 +631,7 @@ return_rc:
* @param dcb DCB to send diagnostics to
*/
static void
diagnostics(ROUTER *router, DCB *dcb)
diagnostics(MXS_ROUTER *router, DCB *dcb)
{
ROUTER_INSTANCE *router_inst = (ROUTER_INSTANCE *) router;
char *weightby;
@ -671,7 +671,7 @@ diagnostics(ROUTER *router, DCB *dcb)
* @param queue The GWBUF with reply data
*/
static void
clientReply(ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_dcb)
{
ss_dassert(backend_dcb->session->client_dcb != NULL);
MXS_SESSION_ROUTE_REPLY(backend_dcb->session, queue);
@ -690,8 +690,8 @@ clientReply(ROUTER *instance, void *router_session, GWBUF *queue, DCB *backend_d
* @param succp Result of action: true if router can continue
*
*/
static void handleError(ROUTER *instance, void *router_session, GWBUF *errbuf,
DCB *problem_dcb, error_action_t action, bool *succp)
static void handleError(MXS_ROUTER *instance, void *router_session, GWBUF *errbuf,
DCB *problem_dcb, mxs_error_action_t action, bool *succp)
{
DCB *client_dcb;
@ -851,7 +851,7 @@ static int handle_state_switch(DCB* dcb, DCB_REASON reason, void * routersession
MXS_SESSION* session = dcb->session;
ROUTER_CLIENT_SES* rses = (ROUTER_CLIENT_SES*) routersession;
SERVICE* service = session->service;
ROUTER* router = (ROUTER *) service->router;
MXS_ROUTER* router = (MXS_ROUTER *) service->router;
if (NULL == dcb->session->router_session && DCB_REASON_ERROR != reason)
{

42
server/modules/routing/readwritesplit/readwritesplit.c
View File

@ -68,17 +68,17 @@
* The functions that implement the router module API
*/
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *session);
static void freeSession(ROUTER *instance, void *session);
static int routeQuery(ROUTER *instance, void *session, GWBUF *queue);
static void diagnostics(ROUTER *instance, DCB *dcb);
static void clientReply(ROUTER *instance, void *router_session, GWBUF *queue,
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *session);
static void freeSession(MXS_ROUTER *instance, void *session);
static int routeQuery(MXS_ROUTER *instance, void *session, GWBUF *queue);
static void diagnostics(MXS_ROUTER *instance, DCB *dcb);
static void clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *queue,
DCB *backend_dcb);
static void handleError(ROUTER *instance, void *router_session,
static void handleError(MXS_ROUTER *instance, void *router_session,
GWBUF *errmsgbuf, DCB *backend_dcb,
error_action_t action, bool *succp);
mxs_error_action_t action, bool *succp);
static uint64_t getCapabilities(void);
/*
@ -142,7 +142,7 @@ static const MXS_ENUM_VALUE master_failure_mode_values[] =
*/
MXS_MODULE *MXS_CREATE_MODULE()
{
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -158,7 +158,7 @@ MXS_MODULE *MXS_CREATE_MODULE()
static MXS_MODULE info =
{
MXS_MODULE_API_ROUTER, MXS_MODULE_GA, ROUTER_VERSION,
MXS_MODULE_API_ROUTER, MXS_MODULE_GA, MXS_ROUTER_VERSION,
"A Read/Write splitting router for enhancement read scalability",
"V1.1.0",
&MyObject,
@ -241,7 +241,7 @@ static bool handle_max_slaves(ROUTER_INSTANCE *router, const char *str)
* @param options The options for this query router
* @return NULL in failure, pointer to router in success.
*/
static ROUTER *createInstance(SERVICE *service, char **options)
static MXS_ROUTER *createInstance(SERVICE *service, char **options)
{
ROUTER_INSTANCE *router;
@ -293,7 +293,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
router->rwsplit_config.max_sescmd_history = 0;
}
return (ROUTER *)router;
return (MXS_ROUTER *)router;
}
/**
@ -313,7 +313,7 @@ static ROUTER *createInstance(SERVICE *service, char **options)
* @param session The MaxScale session (generic connection data)
* @return Session specific data for this session, i.e. a router session
*/
static void *newSession(ROUTER *router_inst, MXS_SESSION *session)
static void *newSession(MXS_ROUTER *router_inst, MXS_SESSION *session)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)router_inst;
ROUTER_CLIENT_SES *client_rses = (ROUTER_CLIENT_SES *)MXS_CALLOC(1, sizeof(ROUTER_CLIENT_SES));
@ -404,7 +404,7 @@ static void *newSession(ROUTER *router_inst, MXS_SESSION *session)
* @param instance The router instance data
* @param session The router session being closed
*/
static void closeSession(ROUTER *instance, void *router_session)
static void closeSession(MXS_ROUTER *instance, void *router_session)
{
ROUTER_CLIENT_SES *router_cli_ses = (ROUTER_CLIENT_SES *)router_session;
CHK_CLIENT_RSES(router_cli_ses);
@ -480,7 +480,7 @@ static void closeSession(ROUTER *instance, void *router_session)
* @param router_client_session Client session
*
*/
static void freeSession(ROUTER *router_instance, void *router_client_session)
static void freeSession(MXS_ROUTER *router_instance, void *router_client_session)
{
ROUTER_CLIENT_SES *router_cli_ses = (ROUTER_CLIENT_SES *)router_client_session;
@ -553,7 +553,7 @@ void close_failed_bref(backend_ref_t *bref, bool fatal)
* @param querybuf Buffer containing the query
* @return 1 on success, 0 on error
*/
static int routeQuery(ROUTER *instance, void *router_session, GWBUF *querybuf)
static int routeQuery(MXS_ROUTER *instance, void *router_session, GWBUF *querybuf)
{
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *) instance;
ROUTER_CLIENT_SES *rses = (ROUTER_CLIENT_SES *) router_session;
@ -590,7 +590,7 @@ static int routeQuery(ROUTER *instance, void *router_session, GWBUF *querybuf)
* @param instance The router instance
* @param dcb The DCB for diagnostic output
*/
static void diagnostics(ROUTER *instance, DCB *dcb)
static void diagnostics(MXS_ROUTER *instance, DCB *dcb)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
char *weightby;
@ -644,7 +644,7 @@ static void diagnostics(ROUTER *instance, DCB *dcb)
* @param backend_dcb The backend DCB
* @param queue The GWBUF with reply data
*/
static void clientReply(ROUTER *instance, void *router_session, GWBUF *writebuf,
static void clientReply(MXS_ROUTER *instance, void *router_session, GWBUF *writebuf,
DCB *backend_dcb)
{
DCB *client_dcb;
@ -1330,9 +1330,9 @@ static bool rwsplit_process_router_options(ROUTER_INSTANCE *router,
* Even if succp == true connecting to new slave may have failed. succp is to
* tell whether router has enough master/slave connections to continue work.
*/
static void handleError(ROUTER *instance, void *router_session,
static void handleError(MXS_ROUTER *instance, void *router_session,
GWBUF *errmsgbuf, DCB *problem_dcb,
error_action_t action, bool *succp)
mxs_error_action_t action, bool *succp)
{
MXS_SESSION *session;
ROUTER_INSTANCE *inst = (ROUTER_INSTANCE *)instance;

2
server/modules/routing/readwritesplit/readwritesplit.h
View File

@ -226,7 +226,7 @@ typedef struct rwsplit_config_st
int max_slave_connections; /**< Maximum number of slaves for each connection*/
select_criteria_t slave_selection_criteria; /**< The slave selection criteria */
int max_slave_replication_lag; /**< Maximum replication lag */
target_t use_sql_variables_in; /**< Whether to send user variables
mxs_target_t use_sql_variables_in; /**< Whether to send user variables
* to master or all nodes */
int max_sescmd_history; /**< Maximum amount of session commands to store */
bool disable_sescmd_history; /**< Disable session command history */

2
server/modules/routing/readwritesplit/rwsplit_route_stmt.c
View File

@ -711,7 +711,7 @@ route_target_t get_route_target(ROUTER_CLIENT_SES *rses,
{
bool trx_active = session_trx_is_active(rses->client_dcb->session);
bool load_active = rses->rses_load_active;
target_t use_sql_variables_in = rses->rses_config.use_sql_variables_in;
mxs_target_t use_sql_variables_in = rses->rses_config.use_sql_variables_in;
route_target_t target = TARGET_UNDEFINED;
if (rses->forced_node && rses->forced_node == rses->rses_master_ref)

48
server/modules/routing/schemarouter/schemarouter.c
View File

@ -57,23 +57,23 @@
* @endverbatim
*/
static ROUTER* createInstance(SERVICE *service, char **options);
static void* newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *session);
static void freeSession(ROUTER *instance, void *session);
static int routeQuery(ROUTER *instance, void *session, GWBUF *queue);
static void diagnostic(ROUTER *instance, DCB *dcb);
static MXS_ROUTER* createInstance(SERVICE *service, char **options);
static void* newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *session);
static void freeSession(MXS_ROUTER *instance, void *session);
static int routeQuery(MXS_ROUTER *instance, void *session, GWBUF *queue);
static void diagnostic(MXS_ROUTER *instance, DCB *dcb);
static void clientReply(ROUTER* instance,
static void clientReply(MXS_ROUTER* instance,
void* router_session,
GWBUF* queue,
DCB* backend_dcb);
static void handleError(ROUTER* instance,
static void handleError(MXS_ROUTER* instance,
void* router_session,
GWBUF* errmsgbuf,
DCB* backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool* succp);
static backend_ref_t* get_bref_from_dcb(ROUTER_CLIENT_SES* rses, DCB* dcb);
@ -599,7 +599,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
spinlock_init(&instlock);
instances = NULL;
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -617,7 +617,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_BETA_RELEASE,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"A database sharding router for simple sharding",
"V1.0.0",
&MyObject,
@ -649,7 +649,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return NULL in failure, pointer to router in success.
*/
static ROUTER* createInstance(SERVICE *service, char **options)
static MXS_ROUTER* createInstance(SERVICE *service, char **options)
{
ROUTER_INSTANCE* router;
MXS_CONFIG_PARAMETER* conf;
@ -815,7 +815,7 @@ static ROUTER* createInstance(SERVICE *service, char **options)
router = NULL;
}
return (ROUTER *)router;
return (MXS_ROUTER *)router;
}
/**
@ -847,7 +847,7 @@ enum shard_map_state shard_map_update_state(shard_map_t *self, ROUTER_INSTANCE*
* @param session The session itself
* @return Session specific data for this session
*/
static void* newSession(ROUTER* router_inst, MXS_SESSION* session)
static void* newSession(MXS_ROUTER* router_inst, MXS_SESSION* session)
{
backend_ref_t* backend_ref; /*< array of backend references (DCB, BACKEND, cursor) */
ROUTER_CLIENT_SES* client_rses = NULL;
@ -1044,7 +1044,7 @@ static void* newSession(ROUTER* router_inst, MXS_SESSION* session)
* @param instance The router instance data
* @param session The session being closed
*/
static void closeSession(ROUTER* instance, void* router_session)
static void closeSession(MXS_ROUTER* instance, void* router_session)
{
ROUTER_CLIENT_SES* router_cli_ses;
ROUTER_INSTANCE* inst;
@ -1139,7 +1139,7 @@ static void closeSession(ROUTER* instance, void* router_session)
}
}
static void freeSession(ROUTER* router_instance, void* router_client_session)
static void freeSession(MXS_ROUTER* router_instance, void* router_client_session)
{
ROUTER_CLIENT_SES* router_cli_ses = (ROUTER_CLIENT_SES *)router_client_session;
@ -1280,7 +1280,7 @@ static route_target_t get_shard_route_target(qc_query_type_t qtype,
* @param querybuf GWBUF containing the query
* @param type The type of the query resolved so far
*/
void check_drop_tmp_table(ROUTER* instance,
void check_drop_tmp_table(MXS_ROUTER* instance,
void* router_session,
GWBUF* querybuf,
qc_query_type_t type)
@ -1334,7 +1334,7 @@ void check_drop_tmp_table(ROUTER* instance,
* @param type The type of the query resolved so far
* @return The type of the query
*/
qc_query_type_t is_read_tmp_table(ROUTER* instance,
qc_query_type_t is_read_tmp_table(MXS_ROUTER* instance,
void* router_session,
GWBUF* querybuf,
qc_query_type_t type)
@ -1411,7 +1411,7 @@ qc_query_type_t is_read_tmp_table(ROUTER* instance,
* @param querybuf GWBUF containing the query
* @param type The type of the query resolved so far
*/
void check_create_tmp_table(ROUTER* instance,
void check_create_tmp_table(MXS_ROUTER* instance,
void* router_session,
GWBUF* querybuf,
qc_query_type_t type)
@ -1615,7 +1615,7 @@ bool send_database_list(ROUTER_INSTANCE* router, ROUTER_CLIENT_SES* client)
* an error message is sent to the client.
*
*/
static int routeQuery(ROUTER* instance,
static int routeQuery(MXS_ROUTER* instance,
void* router_session,
GWBUF* qbuf)
{
@ -2180,7 +2180,7 @@ static void rses_end_locked_router_action(ROUTER_CLIENT_SES* rses)
* @param instance The router instance
* @param dcb The DCB for diagnostic output
*/
static void diagnostic(ROUTER *instance, DCB *dcb)
static void diagnostic(MXS_ROUTER *instance, DCB *dcb)
{
ROUTER_INSTANCE *router = (ROUTER_INSTANCE *)instance;
int i = 0;
@ -2241,7 +2241,7 @@ static void diagnostic(ROUTER *instance, DCB *dcb)
* @param backend_dcb The backend DCB
* @param queue The GWBUF with reply data
*/
static void clientReply(ROUTER* instance,
static void clientReply(MXS_ROUTER* instance,
void* router_session,
GWBUF* buffer,
DCB* backend_dcb)
@ -3559,11 +3559,11 @@ return_succp:
* Even if succp == true connecting to new slave may have failed. succp is to
* tell whether router has enough master/slave connections to continue work.
*/
static void handleError(ROUTER* instance,
static void handleError(MXS_ROUTER* instance,
void* router_session,
GWBUF* errmsgbuf,
DCB* problem_dcb,
error_action_t action,
mxs_error_action_t action,
bool* succp)
{
MXS_SESSION* session;

2
server/modules/routing/schemarouter/schemarouter.h
View File

@ -283,7 +283,7 @@ typedef struct schemarouter_config_st
{
int rw_max_slave_conn_percent;
int rw_max_slave_conn_count;
target_t rw_use_sql_variables_in;
mxs_target_t rw_use_sql_variables_in;
int max_sescmd_hist;
bool disable_sescmd_hist;
time_t last_refresh; /*< Last time the database list was refreshed */

42
server/modules/routing/testroute/testroute.c
View File

@ -15,19 +15,19 @@
#include <maxscale/router.h>
#include <maxscale/modinfo.h>
static ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(ROUTER *instance, MXS_SESSION *session);
static void closeSession(ROUTER *instance, void *session);
static void freeSession(ROUTER *instance, void *session);
static int routeQuery(ROUTER *instance, void *session, GWBUF *queue);
static void clientReply(ROUTER *instance, void *session, GWBUF *queue, DCB*);
static void diagnostic(ROUTER *instance, DCB *dcb);
static MXS_ROUTER *createInstance(SERVICE *service, char **options);
static void *newSession(MXS_ROUTER *instance, MXS_SESSION *session);
static void closeSession(MXS_ROUTER *instance, void *session);
static void freeSession(MXS_ROUTER *instance, void *session);
static int routeQuery(MXS_ROUTER *instance, void *session, GWBUF *queue);
static void clientReply(MXS_ROUTER *instance, void *session, GWBUF *queue, DCB*);
static void diagnostic(MXS_ROUTER *instance, DCB *dcb);
static uint64_t getCapabilities ();
static void handleError(ROUTER *instance,
static void handleError(MXS_ROUTER *instance,
void *router_session,
GWBUF *errbuf,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp);
typedef struct
@ -48,7 +48,7 @@ typedef struct
*/
MXS_MODULE* MXS_CREATE_MODULE()
{
static ROUTER_OBJECT MyObject =
static MXS_ROUTER_OBJECT MyObject =
{
createInstance,
newSession,
@ -66,7 +66,7 @@ MXS_MODULE* MXS_CREATE_MODULE()
{
MXS_MODULE_API_ROUTER,
MXS_MODULE_IN_DEVELOPMENT,
ROUTER_VERSION,
MXS_ROUTER_VERSION,
"A test router - not for use in real systems",
"V1.0.0",
&MyObject,
@ -91,10 +91,10 @@ MXS_MODULE* MXS_CREATE_MODULE()
*
* @return The instance data for this new instance
*/
static ROUTER *
static MXS_ROUTER *
createInstance(SERVICE *service, char **options)
{
return (ROUTER*)MXS_MALLOC(sizeof(TESTROUTER));
return (MXS_ROUTER*)MXS_MALLOC(sizeof(TESTROUTER));
}
/**
@ -105,7 +105,7 @@ createInstance(SERVICE *service, char **options)
* @return Session specific data for this session
*/
static void *
newSession(ROUTER *instance, MXS_SESSION *session)
newSession(MXS_ROUTER *instance, MXS_SESSION *session)
{
return (MXS_SESSION*)MXS_MALLOC(sizeof(TESTSESSION));
}
@ -118,24 +118,24 @@ newSession(ROUTER *instance, MXS_SESSION *session)
* @param session The session being closed
*/
static void
closeSession(ROUTER *instance, void *session)
closeSession(MXS_ROUTER *instance, void *session)
{
}
static void freeSession(
ROUTER* router_instance,
MXS_ROUTER* router_instance,
void* router_client_session)
{
MXS_FREE(router_client_session);
}
static int
routeQuery(ROUTER *instance, void *session, GWBUF *queue)
routeQuery(MXS_ROUTER *instance, void *session, GWBUF *queue)
{
return 0;
}
void clientReply(ROUTER* instance, void* session, GWBUF* queue, DCB* dcb)
void clientReply(MXS_ROUTER* instance, void* session, GWBUF* queue, DCB* dcb)
{
}
@ -146,7 +146,7 @@ void clientReply(ROUTER* instance, void* session, GWBUF* queue, DCB* dcb)
* @param dcb The DCB for diagnostic output
*/
static void
diagnostic(ROUTER *instance, DCB *dcb)
diagnostic(MXS_ROUTER *instance, DCB *dcb)
{
}
@ -157,11 +157,11 @@ static uint64_t getCapabilities(void)
static void handleError(
ROUTER *instance,
MXS_ROUTER *instance,
void *router_session,
GWBUF *errbuf,
DCB *backend_dcb,
error_action_t action,
mxs_error_action_t action,
bool *succp)
{
}