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

Merge branch 'develop' into 1.2.1-binlog_router

Browse Source 
Conflicts:
	server/core/server.c
	server/include/server.h
	server/modules/include/blr.h
	server/modules/routing/binlog/blr.c
	server/modules/routing/binlog/blr_file.c
	server/modules/routing/binlog/blr_master.c
	server/modules/routing/binlog/blr_slave.c
This commit is contained in:
root
2015-08-04 07:59:44 -04:00
parent a28936c5bf 5bde03edb1
commit 61c47375d5
181 changed files with 9740 additions and 4538 deletions
Download Patch File Download Diff File Expand all files Collapse all files

334
server/core/server.c
View File

@ -33,6 +33,7 @@
* 30/08/14 Massimiliano Pinto Addition of new service status description
* 30/10/14 Massimiliano Pinto Addition of SERVER_MASTER_STICKINESS description
* 01/06/15 Massimiliano Pinto Addition of server_update_address/port
* 19/06/15 Martin Brampton Extra code for persistent connections
*
* @endverbatim
*/
@ -43,6 +44,7 @@
#include <server.h>
#include <spinlock.h>
#include <dcb.h>
#include <poll.h>
#include <skygw_utils.h>
#include <log_manager.h>
@ -54,6 +56,8 @@ extern __thread log_info_t tls_log_info;
static SPINLOCK server_spin = SPINLOCK_INIT;
static SERVER *allServers = NULL;
static void spin_reporter(void *, char *, int);
/**
* Allocate a new server withn the gateway
*
@ -71,6 +75,10 @@ SERVER *server;
if ((server = (SERVER *)calloc(1, sizeof(SERVER))) == NULL)
return NULL;
#if defined(SS_DEBUG)
server->server_chk_top = CHK_NUM_SERVER;
server->server_chk_tail = CHK_NUM_SERVER;
#endif
server->name = strdup(servname);
server->protocol = strdup(protocol);
server->port = port;
@ -79,6 +87,9 @@ SERVER *server;
server->rlag = -2;
server->master_id = -1;
server->depth = -1;
server->persistent = NULL;
server->persistmax = 0;
spinlock_init(&server->persistlock);
spinlock_acquire(&server_spin);
server->next = allServers;
@ -96,39 +107,104 @@ SERVER *server;
* @return Returns true if the server was freed
*/
int
server_free(SERVER *server)
server_free(SERVER *tofreeserver)
{
SERVER *ptr;
SERVER *server;
/* First of all remove from the linked list */
spinlock_acquire(&server_spin);
if (allServers == server)
if (allServers == tofreeserver)
{
allServers = server->next;
allServers = tofreeserver->next;
}
else
{
ptr = allServers;
while (ptr && ptr->next != server)
server = allServers;
while (server && server->next != tofreeserver)
{
ptr = ptr->next;
server = server->next;
}
if (ptr)
ptr->next = server->next;
if (server)
server->next = tofreeserver->next;
}
spinlock_release(&server_spin);
/* Clean up session and free the memory */
free(server->name);
free(server->protocol);
if (server->unique_name)
free(server->unique_name);
if (server->server_string)
free(server->server_string);
free(server);
free(tofreeserver->name);
free(tofreeserver->protocol);
if (tofreeserver->unique_name)
free(tofreeserver->unique_name);
if (tofreeserver->server_string)
free(tofreeserver->server_string);
if (tofreeserver->persistent)
dcb_persistent_clean_count(tofreeserver->persistent, true);
free(tofreeserver);
return 1;
}
/**
* Get a DCB from the persistent connection pool, if possible
*
* @param server The server to set the name on
* @param user The name of the user needing the connection
* @param protocol The name of the protocol needed for the connection
*/
DCB *
server_get_persistent(SERVER *server, char *user, const char *protocol)
{
DCB *dcb, *previous = NULL;
if (server->persistent && dcb_persistent_clean_count(server->persistent, false) && server->persistent)
{
spinlock_acquire(&server->persistlock);
dcb = server->persistent;
while (dcb) {
if (dcb->user
&& dcb->protoname
&& !dcb-> dcb_errhandle_called
&& !(dcb->flags & DCBF_HUNG)
&& 0 == strcmp(dcb->user, user)
&& 0 == strcmp(dcb->protoname, protocol))
{
if (NULL == previous)
{
server->persistent = dcb->nextpersistent;
}
else
{
previous->nextpersistent = dcb->nextpersistent;
}
free(dcb->user);
dcb->user = NULL;
spinlock_release(&server->persistlock);
atomic_add(&server->stats.n_persistent, -1);
atomic_add(&server->stats.n_current, 1);
return dcb;
}
else
{
LOGIF(LD, (skygw_log_write_flush(
LOGFILE_DEBUG,
"%lu [server_get_persistent] Rejected dcb "
"%p from pool, user %s looking for %s, protocol %s "
"looking for %s, hung flag %s, error handle called %s.",
pthread_self(),
dcb,
dcb->user ? dcb->user : "NULL",
user,
dcb->protoname ? dcb->protoname : "NULL",
protocol,
(dcb->flags & DCBF_HUNG) ? "true" : "false",
dcb-> dcb_errhandle_called ? "true" : "false")));
}
previous = dcb;
dcb = dcb->nextpersistent;
}
spinlock_release(&server->persistlock);
}
return NULL;
}
/**
* Set a unique name for the server
*
@ -204,6 +280,8 @@ printServer(SERVER *server)
printf("\tPort: %d\n", server->port);
printf("\tTotal connections: %d\n", server->stats.n_connections);
printf("\tCurrent connections: %d\n", server->stats.n_current);
printf("\tPersistent connections: %d\n", server->stats.n_persistent);
printf("\tPersistent actual max: %d\n", server->persistmax);
}
/**
@ -215,14 +293,14 @@ printServer(SERVER *server)
void
printAllServers()
{
SERVER *ptr;
SERVER *server;
spinlock_acquire(&server_spin);
ptr = allServers;
while (ptr)
server = allServers;
while (server)
{
printServer(ptr);
ptr = ptr->next;
printServer(server);
server = server->next;
}
spinlock_release(&server_spin);
}
@ -236,60 +314,73 @@ SERVER *ptr;
void
dprintAllServers(DCB *dcb)
{
SERVER *ptr;
SERVER *server;
char *stat;
spinlock_acquire(&server_spin);
ptr = allServers;
while (ptr)
server = allServers;
while (server)
{
dcb_printf(dcb, "Server %p (%s)\n", ptr, ptr->unique_name);
dcb_printf(dcb, "Server %p (%s)\n", server, server->unique_name);
dcb_printf(dcb, "\tServer: %s\n",
ptr->name);
stat = server_status(ptr);
server->name);
stat = server_status(server);
dcb_printf(dcb, "\tStatus: %s\n",
stat);
free(stat);
dcb_printf(dcb, "\tProtocol: %s\n",
ptr->protocol);
server->protocol);
dcb_printf(dcb, "\tPort: %d\n",
ptr->port);
if (ptr->server_string)
server->port);
if (server->server_string)
dcb_printf(dcb, "\tServer Version:\t\t\t%s\n",
ptr->server_string);
server->server_string);
dcb_printf(dcb, "\tNode Id: %d\n",
ptr->node_id);
server->node_id);
dcb_printf(dcb, "\tMaster Id: %d\n",
ptr->master_id);
if (ptr->slaves) {
server->master_id);
if (server->slaves) {
int i;
dcb_printf(dcb, "\tSlave Ids: ");
for (i = 0; ptr->slaves[i]; i++)
for (i = 0; server->slaves[i]; i++)
{
if (i == 0)
dcb_printf(dcb, "%li", ptr->slaves[i]);
dcb_printf(dcb, "%li", server->slaves[i]);
else
dcb_printf(dcb, ", %li ", ptr->slaves[i]);
dcb_printf(dcb, ", %li ", server->slaves[i]);
}
dcb_printf(dcb, "\n");
}
dcb_printf(dcb, "\tRepl Depth: %d\n",
ptr->depth);
if (SERVER_IS_SLAVE(ptr) || SERVER_IS_RELAY_SERVER(ptr)) {
if (ptr->rlag >= 0) {
dcb_printf(dcb, "\tSlave delay:\t\t%d\n", ptr->rlag);
server->depth);
if (SERVER_IS_SLAVE(server) || SERVER_IS_RELAY_SERVER(server)) {
if (server->rlag >= 0) {
dcb_printf(dcb, "\tSlave delay:\t\t%d\n", server->rlag);
}
}
if (ptr->node_ts > 0) {
dcb_printf(dcb, "\tLast Repl Heartbeat:\t%lu\n", ptr->node_ts);
if (server->node_ts > 0) {
dcb_printf(dcb, "\tLast Repl Heartbeat:\t%lu\n", server->node_ts);
}
dcb_printf(dcb, "\tNumber of connections: %d\n",
ptr->stats.n_connections);
server->stats.n_connections);
dcb_printf(dcb, "\tCurrent no. of conns: %d\n",
ptr->stats.n_current);
server->stats.n_current);
dcb_printf(dcb, "\tCurrent no. of operations: %d\n",
ptr->stats.n_current_ops);
ptr = ptr->next;
server->stats.n_current_ops);
if (server->persistpoolmax)
{
dcb_printf(dcb, "\tPersistent pool size: %d\n",
server->stats.n_persistent);
dcb_printf(dcb, "\tPersistent measured pool size: %d\n",
dcb_persistent_clean_count(server->persistent, false));
dcb_printf(dcb, "\tPersistent max size achieved: %d\n",
server->persistmax);
dcb_printf(dcb, "\tPersistent pool size limit: %d\n",
server->persistpoolmax);
dcb_printf(dcb, "\tPersistent max time (secs): %d\n",
server->persistmaxtime);
}
server = server->next;
}
spinlock_release(&server_spin);
}
@ -303,74 +394,74 @@ char *stat;
void
dprintAllServersJson(DCB *dcb)
{
SERVER *ptr;
SERVER *server;
char *stat;
int len = 0;
int el = 1;
spinlock_acquire(&server_spin);
ptr = allServers;
while (ptr)
server = allServers;
while (server)
{
ptr = ptr->next;
server = server->next;
len++;
}
ptr = allServers;
server = allServers;
dcb_printf(dcb, "[\n");
while (ptr)
while (server)
{
dcb_printf(dcb, " {\n \"server\": \"%s\",\n",
ptr->name);
stat = server_status(ptr);
server->name);
stat = server_status(server);
dcb_printf(dcb, " \"status\": \"%s\",\n",
stat);
free(stat);
dcb_printf(dcb, " \"protocol\": \"%s\",\n",
ptr->protocol);
server->protocol);
dcb_printf(dcb, " \"port\": \"%d\",\n",
ptr->port);
if (ptr->server_string)
server->port);
if (server->server_string)
dcb_printf(dcb, " \"version\": \"%s\",\n",
ptr->server_string);
server->server_string);
dcb_printf(dcb, " \"nodeId\": \"%d\",\n",
ptr->node_id);
server->node_id);
dcb_printf(dcb, " \"masterId\": \"%d\",\n",
ptr->master_id);
if (ptr->slaves) {
server->master_id);
if (server->slaves) {
int i;
dcb_printf(dcb, " \"slaveIds\": [ ");
for (i = 0; ptr->slaves[i]; i++)
for (i = 0; server->slaves[i]; i++)
{
if (i == 0)
dcb_printf(dcb, "%li", ptr->slaves[i]);
dcb_printf(dcb, "%li", server->slaves[i]);
else
dcb_printf(dcb, ", %li ", ptr->slaves[i]);
dcb_printf(dcb, ", %li ", server->slaves[i]);
}
dcb_printf(dcb, "],\n");
}
dcb_printf(dcb, " \"replDepth\": \"%d\",\n",
ptr->depth);
if (SERVER_IS_SLAVE(ptr) || SERVER_IS_RELAY_SERVER(ptr)) {
if (ptr->rlag >= 0) {
dcb_printf(dcb, " \"slaveDelay\": \"%d\",\n", ptr->rlag);
server->depth);
if (SERVER_IS_SLAVE(server) || SERVER_IS_RELAY_SERVER(server)) {
if (server->rlag >= 0) {
dcb_printf(dcb, " \"slaveDelay\": \"%d\",\n", server->rlag);
}
}
if (ptr->node_ts > 0) {
dcb_printf(dcb, " \"lastReplHeartbeat\": \"%lu\",\n", ptr->node_ts);
if (server->node_ts > 0) {
dcb_printf(dcb, " \"lastReplHeartbeat\": \"%lu\",\n", server->node_ts);
}
dcb_printf(dcb, " \"totalConnections\": \"%d\",\n",
ptr->stats.n_connections);
server->stats.n_connections);
dcb_printf(dcb, " \"currentConnections\": \"%d\",\n",
ptr->stats.n_current);
server->stats.n_current);
dcb_printf(dcb, " \"currentOps\": \"%d\"\n",
ptr->stats.n_current_ops);
server->stats.n_current_ops);
if (el < len) {
dcb_printf(dcb, " },\n");
}
else {
dcb_printf(dcb, " }\n");
}
ptr = ptr->next;
server = server->next;
el++;
}
dcb_printf(dcb, "]\n");
@ -440,6 +531,57 @@ SERVER_PARAM *param;
dcb_printf(dcb, "\tCurrent no. of conns: %d\n",
server->stats.n_current);
dcb_printf(dcb, "\tCurrent no. of operations: %d\n", server->stats.n_current_ops);
if (server->persistpoolmax)
{
dcb_printf(dcb, "\tPersistent pool size: %d\n",
server->stats.n_persistent);
dcb_printf(dcb, "\tPersistent measured pool size: %d\n",
dcb_persistent_clean_count(server->persistent, false));
dcb_printf(dcb, "\tPersistent actual size max: %d\n",
server->persistmax);
dcb_printf(dcb, "\tPersistent pool size limit: %d\n",
server->persistpoolmax);
dcb_printf(dcb, "\tPersistent max time (secs): %d\n",
server->persistmaxtime);
}
}
/**
* Display an entry from the spinlock statistics data
*
* @param dcb The DCB to print to
* @param desc Description of the statistic
* @param value The statistic value
*/
static void
spin_reporter(void *dcb, char *desc, int value)
{
dcb_printf((DCB *)dcb, "\t\t%-40s %d\n", desc, value);
}
/**
* Diagnostic to print all DCBs in persistent pool for a server
*
* @param pdcb DCB to print results to
* @param server SERVER for which DCBs are to be printed
*/
void
dprintPersistentDCBs(DCB *pdcb, SERVER *server)
{
DCB *dcb;
spinlock_acquire(&server->persistlock);
#if SPINLOCK_PROFILE
dcb_printf(pdcb, "DCB List Spinlock Statistics:\n");
spinlock_stats(&server->persistlock, spin_reporter, pdcb);
#endif
dcb = server->persistent;
while (dcb)
{
dprintOneDCB(pdcb, dcb);
dcb = dcb->nextpersistent;
}
spinlock_release(&server->persistlock);
}
/**
@ -449,12 +591,12 @@ SERVER_PARAM *param;
void
dListServers(DCB *dcb)
{
SERVER *ptr;
SERVER *server;
char *stat;
spinlock_acquire(&server_spin);
ptr = allServers;
if (ptr)
server = allServers;
if (server)
{
dcb_printf(dcb, "Servers.\n");
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
@ -462,15 +604,15 @@ char *stat;
"Server", "Address", "Status");
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
}
while (ptr)
while (server)
{
stat = server_status(ptr);
stat = server_status(server);
dcb_printf(dcb, "%-18s | %-15s | %5d | %11d | %s\n",
ptr->unique_name, ptr->name,
ptr->port,
ptr->stats.n_current, stat);
server->unique_name, server->name,
server->port,
server->stats.n_current, stat);
free(stat);
ptr = ptr->next;
server = server->next;
}
if (allServers)
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
@ -489,7 +631,7 @@ server_status(SERVER *server)
{
char *status = NULL;
if ((status = (char *)malloc(256)) == NULL)
if (NULL == server || (status = (char *)malloc(256)) == NULL)
return NULL;
status[0] = 0;
if (server->status & SERVER_MAINT)
@ -641,7 +783,7 @@ SERVER_PARAM *param;
}
/**
* Retreive a parameter value from a server
* Retrieve a parameter value from a server
*
* @param server The server we are looking for a parameter of
* @param name The name of the parameter we require
@ -675,16 +817,16 @@ int *rowno = (int *)data;
int i = 0;;
char *stat, buf[20];
RESULT_ROW *row;
SERVER *ptr;
SERVER *server;
spinlock_acquire(&server_spin);
ptr = allServers;
while (i < *rowno && ptr)
server = allServers;
while (i < *rowno && server)
{
i++;
ptr = ptr->next;
server = server->next;
}
if (ptr == NULL)
if (server == NULL)
{
spinlock_release(&server_spin);
free(data);
@ -692,13 +834,13 @@ SERVER *ptr;
}
(*rowno)++;
row = resultset_make_row(set);
resultset_row_set(row, 0, ptr->unique_name);
resultset_row_set(row, 1, ptr->name);
sprintf(buf, "%d", ptr->port);
resultset_row_set(row, 0, server->unique_name);
resultset_row_set(row, 1, server->name);
sprintf(buf, "%d", server->port);
resultset_row_set(row, 2, buf);
sprintf(buf, "%d", ptr->stats.n_current);
sprintf(buf, "%d", server->stats.n_current);
resultset_row_set(row, 3, buf);
stat = server_status(ptr);
stat = server_status(server);
resultset_row_set(row, 4, stat);
free(stat);
spinlock_release(&server_spin);