61c47375d5
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
915 lines
24 KiB
C
915 lines
24 KiB
C
/*
|
|
* This file is distributed as part of the MariaDB Corporation MaxScale. It is free
|
|
* software: you can redistribute it and/or modify it under the terms of the
|
|
* GNU General Public License as published by the Free Software Foundation,
|
|
* version 2.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program; if not, write to the Free Software Foundation, Inc., 51
|
|
* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Copyright MariaDB Corporation Ab 2013-2014
|
|
*/
|
|
|
|
/**
|
|
* @file server.c - A representation of a backend server within the gateway.
|
|
*
|
|
* @verbatim
|
|
* Revision History
|
|
*
|
|
* Date Who Description
|
|
* 18/06/13 Mark Riddoch Initial implementation
|
|
* 17/05/14 Mark Riddoch Addition of unique_name
|
|
* 20/05/14 Massimiliano Pinto Addition of server_string
|
|
* 21/05/14 Massimiliano Pinto Addition of node_id
|
|
* 28/05/14 Massimiliano Pinto Addition of rlagd and node_ts fields
|
|
* 20/06/14 Massimiliano Pinto Addition of master_id, depth, slaves fields
|
|
* 26/06/14 Mark Riddoch Addition of server parameters
|
|
* 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
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <session.h>
|
|
#include <server.h>
|
|
#include <spinlock.h>
|
|
#include <dcb.h>
|
|
#include <poll.h>
|
|
#include <skygw_utils.h>
|
|
#include <log_manager.h>
|
|
|
|
/** Defined in log_manager.cc */
|
|
extern int lm_enabled_logfiles_bitmask;
|
|
extern size_t log_ses_count[];
|
|
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
|
|
*
|
|
*
|
|
* @param servname The server name
|
|
* @param protocol The protocol to use to connect to the server
|
|
* @param port The port to connect to
|
|
*
|
|
* @return The newly created server or NULL if an error occured
|
|
*/
|
|
SERVER *
|
|
server_alloc(char *servname, char *protocol, unsigned short port)
|
|
{
|
|
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;
|
|
server->status = SERVER_RUNNING;
|
|
server->node_id = -1;
|
|
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;
|
|
allServers = server;
|
|
spinlock_release(&server_spin);
|
|
|
|
return server;
|
|
}
|
|
|
|
|
|
/**
|
|
* Deallocate the specified server
|
|
*
|
|
* @param server The service to deallocate
|
|
* @return Returns true if the server was freed
|
|
*/
|
|
int
|
|
server_free(SERVER *tofreeserver)
|
|
{
|
|
SERVER *server;
|
|
|
|
/* First of all remove from the linked list */
|
|
spinlock_acquire(&server_spin);
|
|
if (allServers == tofreeserver)
|
|
{
|
|
allServers = tofreeserver->next;
|
|
}
|
|
else
|
|
{
|
|
server = allServers;
|
|
while (server && server->next != tofreeserver)
|
|
{
|
|
server = server->next;
|
|
}
|
|
if (server)
|
|
server->next = tofreeserver->next;
|
|
}
|
|
spinlock_release(&server_spin);
|
|
|
|
/* Clean up session and free the memory */
|
|
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
|
|
*
|
|
* @param server The server to set the name on
|
|
* @param name The unique name for the server
|
|
*/
|
|
void
|
|
server_set_unique_name(SERVER *server, char *name)
|
|
{
|
|
server->unique_name = strdup(name);
|
|
}
|
|
|
|
/**
|
|
* Find an existing server using the unique section name in
|
|
* configuration file
|
|
*
|
|
* @param servname The Server name or address
|
|
* @param port The server port
|
|
* @return The server or NULL if not found
|
|
*/
|
|
SERVER *
|
|
server_find_by_unique_name(char *name)
|
|
{
|
|
SERVER *server;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (server)
|
|
{
|
|
if (server->unique_name && strcmp(server->unique_name, name) == 0)
|
|
break;
|
|
server = server->next;
|
|
}
|
|
spinlock_release(&server_spin);
|
|
return server;
|
|
}
|
|
|
|
/**
|
|
* Find an existing server
|
|
*
|
|
* @param servname The Server name or address
|
|
* @param port The server port
|
|
* @return The server or NULL if not found
|
|
*/
|
|
SERVER *
|
|
server_find(char *servname, unsigned short port)
|
|
{
|
|
SERVER *server;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (server)
|
|
{
|
|
if (strcmp(server->name, servname) == 0 && server->port == port)
|
|
break;
|
|
server = server->next;
|
|
}
|
|
spinlock_release(&server_spin);
|
|
return server;
|
|
}
|
|
|
|
/**
|
|
* Print details of an individual server
|
|
*
|
|
* @param server Server to print
|
|
*/
|
|
void
|
|
printServer(SERVER *server)
|
|
{
|
|
printf("Server %p\n", server);
|
|
printf("\tServer: %s\n", server->name);
|
|
printf("\tProtocol: %s\n", server->protocol);
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Print all servers
|
|
*
|
|
* Designed to be called within a debugger session in order
|
|
* to display all active servers within the gateway
|
|
*/
|
|
void
|
|
printAllServers()
|
|
{
|
|
SERVER *server;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (server)
|
|
{
|
|
printServer(server);
|
|
server = server->next;
|
|
}
|
|
spinlock_release(&server_spin);
|
|
}
|
|
|
|
/**
|
|
* Print all servers to a DCB
|
|
*
|
|
* Designed to be called within a debugger session in order
|
|
* to display all active servers within the gateway
|
|
*/
|
|
void
|
|
dprintAllServers(DCB *dcb)
|
|
{
|
|
SERVER *server;
|
|
char *stat;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (server)
|
|
{
|
|
dcb_printf(dcb, "Server %p (%s)\n", server, server->unique_name);
|
|
dcb_printf(dcb, "\tServer: %s\n",
|
|
server->name);
|
|
stat = server_status(server);
|
|
dcb_printf(dcb, "\tStatus: %s\n",
|
|
stat);
|
|
free(stat);
|
|
dcb_printf(dcb, "\tProtocol: %s\n",
|
|
server->protocol);
|
|
dcb_printf(dcb, "\tPort: %d\n",
|
|
server->port);
|
|
if (server->server_string)
|
|
dcb_printf(dcb, "\tServer Version:\t\t\t%s\n",
|
|
server->server_string);
|
|
dcb_printf(dcb, "\tNode Id: %d\n",
|
|
server->node_id);
|
|
dcb_printf(dcb, "\tMaster Id: %d\n",
|
|
server->master_id);
|
|
if (server->slaves) {
|
|
int i;
|
|
dcb_printf(dcb, "\tSlave Ids: ");
|
|
for (i = 0; server->slaves[i]; i++)
|
|
{
|
|
if (i == 0)
|
|
dcb_printf(dcb, "%li", server->slaves[i]);
|
|
else
|
|
dcb_printf(dcb, ", %li ", server->slaves[i]);
|
|
}
|
|
dcb_printf(dcb, "\n");
|
|
}
|
|
dcb_printf(dcb, "\tRepl Depth: %d\n",
|
|
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 (server->node_ts > 0) {
|
|
dcb_printf(dcb, "\tLast Repl Heartbeat:\t%lu\n", server->node_ts);
|
|
}
|
|
dcb_printf(dcb, "\tNumber of connections: %d\n",
|
|
server->stats.n_connections);
|
|
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 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);
|
|
}
|
|
|
|
/**
|
|
* Print all servers in Json format to a DCB
|
|
*
|
|
* Designed to be called within a debugger session in order
|
|
* to display all active servers within the gateway
|
|
*/
|
|
void
|
|
dprintAllServersJson(DCB *dcb)
|
|
{
|
|
SERVER *server;
|
|
char *stat;
|
|
int len = 0;
|
|
int el = 1;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (server)
|
|
{
|
|
server = server->next;
|
|
len++;
|
|
}
|
|
server = allServers;
|
|
dcb_printf(dcb, "[\n");
|
|
while (server)
|
|
{
|
|
dcb_printf(dcb, " {\n \"server\": \"%s\",\n",
|
|
server->name);
|
|
stat = server_status(server);
|
|
dcb_printf(dcb, " \"status\": \"%s\",\n",
|
|
stat);
|
|
free(stat);
|
|
dcb_printf(dcb, " \"protocol\": \"%s\",\n",
|
|
server->protocol);
|
|
dcb_printf(dcb, " \"port\": \"%d\",\n",
|
|
server->port);
|
|
if (server->server_string)
|
|
dcb_printf(dcb, " \"version\": \"%s\",\n",
|
|
server->server_string);
|
|
dcb_printf(dcb, " \"nodeId\": \"%d\",\n",
|
|
server->node_id);
|
|
dcb_printf(dcb, " \"masterId\": \"%d\",\n",
|
|
server->master_id);
|
|
if (server->slaves) {
|
|
int i;
|
|
dcb_printf(dcb, " \"slaveIds\": [ ");
|
|
for (i = 0; server->slaves[i]; i++)
|
|
{
|
|
if (i == 0)
|
|
dcb_printf(dcb, "%li", server->slaves[i]);
|
|
else
|
|
dcb_printf(dcb, ", %li ", server->slaves[i]);
|
|
}
|
|
dcb_printf(dcb, "],\n");
|
|
}
|
|
dcb_printf(dcb, " \"replDepth\": \"%d\",\n",
|
|
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 (server->node_ts > 0) {
|
|
dcb_printf(dcb, " \"lastReplHeartbeat\": \"%lu\",\n", server->node_ts);
|
|
}
|
|
dcb_printf(dcb, " \"totalConnections\": \"%d\",\n",
|
|
server->stats.n_connections);
|
|
dcb_printf(dcb, " \"currentConnections\": \"%d\",\n",
|
|
server->stats.n_current);
|
|
dcb_printf(dcb, " \"currentOps\": \"%d\"\n",
|
|
server->stats.n_current_ops);
|
|
if (el < len) {
|
|
dcb_printf(dcb, " },\n");
|
|
}
|
|
else {
|
|
dcb_printf(dcb, " }\n");
|
|
}
|
|
server = server->next;
|
|
el++;
|
|
}
|
|
dcb_printf(dcb, "]\n");
|
|
spinlock_release(&server_spin);
|
|
}
|
|
|
|
|
|
/**
|
|
* Print server details to a DCB
|
|
*
|
|
* Designed to be called within a debugger session in order
|
|
* to display all active servers within the gateway
|
|
*/
|
|
void
|
|
dprintServer(DCB *dcb, SERVER *server)
|
|
{
|
|
char *stat;
|
|
SERVER_PARAM *param;
|
|
|
|
dcb_printf(dcb, "Server %p (%s)\n", server, server->unique_name);
|
|
dcb_printf(dcb, "\tServer: %s\n", server->name);
|
|
stat = server_status(server);
|
|
dcb_printf(dcb, "\tStatus: %s\n", stat);
|
|
free(stat);
|
|
dcb_printf(dcb, "\tProtocol: %s\n", server->protocol);
|
|
dcb_printf(dcb, "\tPort: %d\n", server->port);
|
|
if (server->server_string)
|
|
dcb_printf(dcb, "\tServer Version:\t\t\t%s\n", server->server_string);
|
|
dcb_printf(dcb, "\tNode Id: %d\n", server->node_id);
|
|
dcb_printf(dcb, "\tMaster Id: %d\n", server->master_id);
|
|
if (server->slaves) {
|
|
int i;
|
|
dcb_printf(dcb, "\tSlave Ids: ");
|
|
for (i = 0; server->slaves[i]; i++)
|
|
{
|
|
if (i == 0)
|
|
dcb_printf(dcb, "%li", server->slaves[i]);
|
|
else
|
|
dcb_printf(dcb, ", %li ", server->slaves[i]);
|
|
}
|
|
dcb_printf(dcb, "\n");
|
|
}
|
|
dcb_printf(dcb, "\tRepl Depth: %d\n", 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 (server->node_ts > 0) {
|
|
struct tm result;
|
|
char buf[40];
|
|
dcb_printf(dcb, "\tLast Repl Heartbeat:\t%s",
|
|
asctime_r(localtime_r((time_t *)(&server->node_ts), &result), buf));
|
|
}
|
|
if ((param = server->parameters) != NULL)
|
|
{
|
|
dcb_printf(dcb, "\tServer Parameters:\n");
|
|
while (param)
|
|
{
|
|
dcb_printf(dcb, "\t\t%-20s\t%s\n", param->name,
|
|
param->value);
|
|
param = param->next;
|
|
}
|
|
}
|
|
dcb_printf(dcb, "\tNumber of connections: %d\n",
|
|
server->stats.n_connections);
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* List all servers in a tabular form to a DCB
|
|
*
|
|
*/
|
|
void
|
|
dListServers(DCB *dcb)
|
|
{
|
|
SERVER *server;
|
|
char *stat;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
if (server)
|
|
{
|
|
dcb_printf(dcb, "Servers.\n");
|
|
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
|
|
dcb_printf(dcb, "%-18s | %-15s | Port | Connections | %-20s\n",
|
|
"Server", "Address", "Status");
|
|
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
|
|
}
|
|
while (server)
|
|
{
|
|
stat = server_status(server);
|
|
dcb_printf(dcb, "%-18s | %-15s | %5d | %11d | %s\n",
|
|
server->unique_name, server->name,
|
|
server->port,
|
|
server->stats.n_current, stat);
|
|
free(stat);
|
|
server = server->next;
|
|
}
|
|
if (allServers)
|
|
dcb_printf(dcb, "-------------------+-----------------+-------+-------------+--------------------\n");
|
|
spinlock_release(&server_spin);
|
|
}
|
|
|
|
/**
|
|
* Convert a set of server status flags to a string, the returned
|
|
* string has been malloc'd and must be free'd by the caller
|
|
*
|
|
* @param server The server to return the status of
|
|
* @return A string representation of the status flags
|
|
*/
|
|
char *
|
|
server_status(SERVER *server)
|
|
{
|
|
char *status = NULL;
|
|
|
|
if (NULL == server || (status = (char *)malloc(256)) == NULL)
|
|
return NULL;
|
|
status[0] = 0;
|
|
if (server->status & SERVER_MAINT)
|
|
strcat(status, "Maintenance, ");
|
|
if (server->status & SERVER_MASTER)
|
|
strcat(status, "Master, ");
|
|
if (server->status & SERVER_SLAVE)
|
|
strcat(status, "Slave, ");
|
|
if (server->status & SERVER_JOINED)
|
|
strcat(status, "Synced, ");
|
|
if (server->status & SERVER_NDB)
|
|
strcat(status, "NDB, ");
|
|
if (server->status & SERVER_SLAVE_OF_EXTERNAL_MASTER)
|
|
strcat(status, "Slave of External Server, ");
|
|
if (server->status & SERVER_STALE_STATUS)
|
|
strcat(status, "Stale Status, ");
|
|
if (server->status & SERVER_MASTER_STICKINESS)
|
|
strcat(status, "Master Stickiness, ");
|
|
if (server->status & SERVER_AUTH_ERROR)
|
|
strcat(status, "Auth Error, ");
|
|
if (server->status & SERVER_RUNNING)
|
|
strcat(status, "Running");
|
|
else
|
|
strcat(status, "Down");
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* Set a status bit in the server
|
|
*
|
|
* @param server The server to update
|
|
* @param bit The bit to set for the server
|
|
*/
|
|
void
|
|
server_set_status(SERVER *server, int bit)
|
|
{
|
|
server->status |= bit;
|
|
|
|
/** clear error logged flag before the next failure */
|
|
if (SERVER_IS_MASTER(server))
|
|
{
|
|
server->master_err_is_logged = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear a status bit in the server
|
|
*
|
|
* @param server The server to update
|
|
* @param bit The bit to clear for the server
|
|
*/
|
|
void
|
|
server_clear_status(SERVER *server, int bit)
|
|
{
|
|
server->status &= ~bit;
|
|
}
|
|
|
|
/**
|
|
* Add a user name and password to use for monitoring the
|
|
* state of the server.
|
|
*
|
|
* @param server The server to update
|
|
* @param user The user name to use
|
|
* @param passwd The password of the user
|
|
*/
|
|
void
|
|
serverAddMonUser(SERVER *server, char *user, char *passwd)
|
|
{
|
|
server->monuser = strdup(user);
|
|
server->monpw = strdup(passwd);
|
|
}
|
|
|
|
/**
|
|
* Check and update a server definition following a configuration
|
|
* update. Changes will not affect any current connections to this
|
|
* server, however all new connections will use the new settings.
|
|
*
|
|
* If the new settings are different from those already applied to the
|
|
* server then a message will be written to the log.
|
|
*
|
|
* @param server The server to update
|
|
* @param protocol The new protocol for the server
|
|
* @param user The monitor user for the server
|
|
* @param passwd The password to use for the monitor user
|
|
*/
|
|
void
|
|
server_update(SERVER *server, char *protocol, char *user, char *passwd)
|
|
{
|
|
if (!strcmp(server->protocol, protocol))
|
|
{
|
|
LOGIF(LM, (skygw_log_write(
|
|
LOGFILE_MESSAGE,
|
|
"Update server protocol for server %s to protocol %s.",
|
|
server->name,
|
|
protocol)));
|
|
free(server->protocol);
|
|
server->protocol = strdup(protocol);
|
|
}
|
|
|
|
if (user != NULL && passwd != NULL) {
|
|
if (strcmp(server->monuser, user) == 0 ||
|
|
strcmp(server->monpw, passwd) == 0)
|
|
{
|
|
LOGIF(LM, (skygw_log_write(
|
|
LOGFILE_MESSAGE,
|
|
"Update server monitor credentials for server %s",
|
|
server->name)));
|
|
free(server->monuser);
|
|
free(server->monpw);
|
|
serverAddMonUser(server, user, passwd);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Add a server parameter to a server.
|
|
*
|
|
* Server parameters may be used by routing to weight the load
|
|
* balancing they apply to the server.
|
|
*
|
|
* @param server The server we are adding the parameter to
|
|
* @param name The parameter name
|
|
* @param value The parameter value
|
|
*/
|
|
void
|
|
serverAddParameter(SERVER *server, char *name, char *value)
|
|
{
|
|
SERVER_PARAM *param;
|
|
|
|
if ((param = (SERVER_PARAM *)malloc(sizeof(SERVER_PARAM))) == NULL)
|
|
{
|
|
return;
|
|
}
|
|
if ((param->name = strdup(name)) == NULL)
|
|
{
|
|
free(param);
|
|
return;
|
|
}
|
|
if ((param->value = strdup(value)) == NULL)
|
|
{
|
|
free(param->value);
|
|
free(param);
|
|
return;
|
|
}
|
|
|
|
param->next = server->parameters;
|
|
server->parameters = param;
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* @return The parameter value or NULL if not found
|
|
*/
|
|
char *
|
|
serverGetParameter(SERVER *server, char *name)
|
|
{
|
|
SERVER_PARAM *param = server->parameters;
|
|
|
|
while (param)
|
|
{
|
|
if (strcmp(param->name, name) == 0)
|
|
return param->value;
|
|
param = param->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Provide a row to the result set that defines the set of servers
|
|
*
|
|
* @param set The result set
|
|
* @param data The index of the row to send
|
|
* @return The next row or NULL
|
|
*/
|
|
static RESULT_ROW *
|
|
serverRowCallback(RESULTSET *set, void *data)
|
|
{
|
|
int *rowno = (int *)data;
|
|
int i = 0;;
|
|
char *stat, buf[20];
|
|
RESULT_ROW *row;
|
|
SERVER *server;
|
|
|
|
spinlock_acquire(&server_spin);
|
|
server = allServers;
|
|
while (i < *rowno && server)
|
|
{
|
|
i++;
|
|
server = server->next;
|
|
}
|
|
if (server == NULL)
|
|
{
|
|
spinlock_release(&server_spin);
|
|
free(data);
|
|
return NULL;
|
|
}
|
|
(*rowno)++;
|
|
row = resultset_make_row(set);
|
|
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", server->stats.n_current);
|
|
resultset_row_set(row, 3, buf);
|
|
stat = server_status(server);
|
|
resultset_row_set(row, 4, stat);
|
|
free(stat);
|
|
spinlock_release(&server_spin);
|
|
return row;
|
|
}
|
|
|
|
/**
|
|
* Return a resultset that has the current set of servers in it
|
|
*
|
|
* @return A Result set
|
|
*/
|
|
RESULTSET *
|
|
serverGetList()
|
|
{
|
|
RESULTSET *set;
|
|
int *data;
|
|
|
|
if ((data = (int *)malloc(sizeof(int))) == NULL)
|
|
return NULL;
|
|
*data = 0;
|
|
if ((set = resultset_create(serverRowCallback, data)) == NULL)
|
|
{
|
|
free(data);
|
|
return NULL;
|
|
}
|
|
resultset_add_column(set, "Server", 20, COL_TYPE_VARCHAR);
|
|
resultset_add_column(set, "Address", 15, COL_TYPE_VARCHAR);
|
|
resultset_add_column(set, "Port", 5, COL_TYPE_VARCHAR);
|
|
resultset_add_column(set, "Connections", 8, COL_TYPE_VARCHAR);
|
|
resultset_add_column(set, "Status", 20, COL_TYPE_VARCHAR);
|
|
|
|
return set;
|
|
}
|
|
|
|
/*
|
|
* Update the address value of a specific server
|
|
*
|
|
* @param server The server to update
|
|
* @param address The new address
|
|
*
|
|
*/
|
|
void
|
|
server_update_address(SERVER *server, char *address)
|
|
{
|
|
spinlock_acquire(&server_spin);
|
|
if (server && address) {
|
|
if (server->name) {
|
|
free(server->name);
|
|
}
|
|
server->name = strdup(address);
|
|
}
|
|
spinlock_release(&server_spin);
|
|
}
|
|
|
|
/*
|
|
* Update the port value of a specific server
|
|
*
|
|
* @param server The server to update
|
|
* @param port The new port value
|
|
*
|
|
*/
|
|
void
|
|
server_update_port(SERVER *server, unsigned short port)
|
|
{
|
|
spinlock_acquire(&server_spin);
|
|
if (server && port > 0) {
|
|
server->port = port;
|
|
}
|
|
spinlock_release(&server_spin);
|
|
}
|
|
|