diff --git a/server/core/server.c b/server/core/server.c
index f67034308..341e1fd75 100644
--- a/server/core/server.c
+++ b/server/core/server.c
@@ -22,18 +22,18 @@
  * @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
+ * 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
  */
@@ -48,8 +48,8 @@
 #include <skygw_utils.h>
 #include <log_manager.h>
 
-static SPINLOCK	server_spin = SPINLOCK_INIT;
-static SERVER	*allServers = NULL;
+static SPINLOCK server_spin = SPINLOCK_INIT;
+static SERVER *allServers = NULL;
 
 static void spin_reporter(void *, char *, int);
 
@@ -57,93 +57,103 @@ 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
+ * @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
+ * @return              The newly created server or NULL if an error occured
  */
 SERVER *
 server_alloc(char *servname, char *protocol, unsigned short port)
 {
-SERVER 	*server;
+    SERVER *server;
 
-	if ((server = (SERVER *)calloc(1, sizeof(SERVER))) == NULL)
-		return NULL;
+    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;
+    server->server_chk_top = CHK_NUM_SERVER;
+    server->server_chk_tail = CHK_NUM_SERVER;
 #endif
-	server->name = strndup(servname, MAX_SERVER_NAME_LEN);
-	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;
-	spinlock_init(&server->lock);
-        server->persistent = NULL;
-        server->persistmax = 0;
-        spinlock_init(&server->persistlock);
+    server->name = strndup(servname, MAX_SERVER_NAME_LEN);
+    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;
+    spinlock_init(&server->lock);
+    server->persistent = NULL;
+    server->persistmax = 0;
+    spinlock_init(&server->persistlock);
 
-	spinlock_acquire(&server_spin);
-	server->next = allServers;
-	allServers = server;
-	spinlock_release(&server_spin);
+    spinlock_acquire(&server_spin);
+    server->next = allServers;
+    allServers = server;
+    spinlock_release(&server_spin);
 
-	return server;
+    return server;
 }
 
 
 /**
  * Deallocate the specified server
  *
- * @param server	The service to deallocate
- * @return	Returns true if the server was freed
+ * @param server        The service to deallocate
+ * @return Returns true if the server was freed
  */
 int
 server_free(SERVER *tofreeserver)
 {
-SERVER *server;
+    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);
+    /* 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;
+    /* 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
+ * @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)
@@ -157,7 +167,8 @@ server_get_persistent(SERVER *server, char *user, const char *protocol)
     {
         spinlock_acquire(&server->persistlock);
         dcb = server->persistent;
-        while (dcb) {
+        while (dcb)
+        {
             if (dcb->user
                 && dcb->protoname
                 && !dcb-> dcb_errhandle_called
@@ -205,80 +216,84 @@ server_get_persistent(SERVER *server, char *user, const char *protocol)
 /**
  * Set a unique name for the server
  *
- * @param	server	The server to set the name on
- * @param	name	The 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);
+    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
+ * @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;
+    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;
+    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
+ * @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;
+    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;
+    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
+ * @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);
+    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);
 }
 
 /**
@@ -290,16 +305,16 @@ printServer(SERVER *server)
 void
 printAllServers()
 {
-SERVER	*server;
+    SERVER *server;
 
-	spinlock_acquire(&server_spin);
-	server = allServers;
-	while (server)
-	{
-		printServer(server);
-		server = server->next;
-	}
-	spinlock_release(&server_spin);
+    spinlock_acquire(&server_spin);
+    server = allServers;
+    while (server)
+    {
+        printServer(server);
+        server = server->next;
+    }
+    spinlock_release(&server_spin);
 }
 
 /**
@@ -311,75 +326,83 @@ SERVER	*server;
 void
 dprintAllServers(DCB *dcb)
 {
-SERVER	*server;
-char	*stat;
+    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)
+    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, "\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);
+                    dcb_printf(dcb, "%li", server->slaves[i]);
                 }
-                server = server->next;
-	}
-	spinlock_release(&server_spin);
+                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);
 }
 
 /**
@@ -391,78 +414,90 @@ char	*stat;
 void
 dprintAllServersJson(DCB *dcb)
 {
-SERVER	*server;
-char	*stat;
-int	len = 0;
-int	el = 1;
+    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);
+    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);
 }
 
 
@@ -475,72 +510,82 @@ int	el = 1;
 void
 dprintServer(DCB *dcb, SERVER *server)
 {
-char		*stat;
-SERVER_PARAM	*param;
+    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, "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++)
         {
-            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);
+            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);
+    }
 }
 
 /**
@@ -553,7 +598,7 @@ SERVER_PARAM	*param;
 static void
 spin_reporter(void *dcb, char *desc, int value)
 {
-	dcb_printf((DCB *)dcb, "\t\t%-40s  %d\n", desc, value);
+    dcb_printf((DCB *)dcb, "\t\t%-40s  %d\n", desc, value);
 }
 
 /**
@@ -565,20 +610,20 @@ spin_reporter(void *dcb, char *desc, int value)
 void
 dprintPersistentDCBs(DCB *pdcb, SERVER *server)
 {
-DCB	*dcb;
+    DCB *dcb;
 
-	spinlock_acquire(&server->persistlock);
+    spinlock_acquire(&server->persistlock);
 #if SPINLOCK_PROFILE
-	dcb_printf(pdcb, "DCB List Spinlock Statistics:\n");
-	spinlock_stats(&server->persistlock, spin_reporter, pdcb);
+    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);
+    dcb = server->persistent;
+    while (dcb)
+    {
+        dprintOneDCB(pdcb, dcb);
+        dcb = dcb->nextpersistent;
+    }
+    spinlock_release(&server->persistlock);
 }
 
 /**
@@ -588,32 +633,34 @@ DCB	*dcb;
 void
 dListServers(DCB *dcb)
 {
-SERVER	*server;
-char	*stat;
+    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);
+    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);
 }
 
 /**
@@ -626,69 +673,93 @@ char	*stat;
 char *
 server_status(SERVER *server)
 {
-char	*status = NULL;
+    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;
+    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
+ * @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;
+    server->status |= bit;
 
-	/** clear error logged flag before the next failure */
-	if (SERVER_IS_MASTER(server))
-	{
-		server->master_err_is_logged = false;
-	}
+    /** clear error logged flag before the next failure */
+    if (SERVER_IS_MASTER(server))
+    {
+        server->master_err_is_logged = false;
+    }
 }
 
 /**
  * Set one or more status bit(s) from a specified set, clearing any others
  * in the specified set
  *
- * @param server	The server to update
- * @param bit		The bit to set for the server
+ * @param server        The server to update
+ * @param bit           The bit to set for the server
  */
 void
 server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set)
 {
-	/** clear error logged flag before the next failure */
-	if ((bits_to_set & SERVER_MASTER) && ((server->status & SERVER_MASTER) == 0))
-	{
-		server->master_err_is_logged = false;
-	}
+    /** clear error logged flag before the next failure */
+    if ((bits_to_set & SERVER_MASTER) && ((server->status & SERVER_MASTER) == 0))
+    {
+        server->master_err_is_logged = false;
+    }
 
     if ((server->status & specified_bits) != bits_to_set)
     {
@@ -699,40 +770,40 @@ server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set)
 /**
  * Clear a status bit in the server
  *
- * @param server	The server to update
- * @param bit		The bit to clear for 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;
+    server->status &= ~bit;
 }
 
 /**
  * Transfer status bitstring from one server to another
  *
  * @param dest_server       The server to be updated
- * @param source_server		The server to provide the new bit string
+ * @param source_server         The server to provide the new bit string
  */
 void
 server_transfer_status(SERVER *dest_server, SERVER *source_server)
 {
-	dest_server->status = source_server->status;
+    dest_server->status = source_server->status;
 }
 
 /**
  * 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
+ * @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);
+    server->monuser = strdup(user);
+    server->monpw = strdup(passwd);
 }
 
 /**
@@ -743,34 +814,35 @@ serverAddMonUser(SERVER *server, char *user, char *passwd)
  * 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
+ * @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))
-	{
-            MXS_NOTICE("Update server protocol for server %s to protocol %s.",
-                       server->name,
-                       protocol);
-            free(server->protocol);
-            server->protocol = strdup(protocol);
-	}
+    if (!strcmp(server->protocol, protocol))
+    {
+        MXS_NOTICE("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)
-                {
-                    MXS_NOTICE("Update server monitor credentials for server %s",
-                               server->name);
-                    free(server->monuser);
-                    free(server->monpw);
-                    serverAddMonUser(server, user, passwd);
-                }
-	}
+    if (user != NULL && passwd != NULL)
+    {
+        if (strcmp(server->monuser, user) == 0 ||
+            strcmp(server->monpw, passwd) == 0)
+        {
+            MXS_NOTICE("Update server monitor credentials for server %s",
+                       server->name);
+            free(server->monuser);
+            free(server->monpw);
+            serverAddMonUser(server, user, passwd);
+        }
+    }
 }
 
 
@@ -780,98 +852,100 @@ server_update(SERVER *server, char *protocol, char *user, char *passwd)
  * 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
+ * @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;
+    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;
-	}
+    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;
+    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
+ * @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;
+    SERVER_PARAM *param = server->parameters;
 
-	while (param)
-	{
-		if (strcmp(param->name, name) == 0)
-			return param->value;
-		param = param->next;
-	}
-	return NULL;
+    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
+ * @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;
+    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;
+    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;
 }
 
 /**
@@ -882,92 +956,102 @@ SERVER		*server;
 RESULTSET *
 serverGetList()
 {
-RESULTSET	*set;
-int		*data;
+    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);
+    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;
+    return set;
 }
 
 /*
  * Update the address value of a specific server
  *
  * @param server        The server to update
- * @param address      	The new address
+ * @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);
+    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
+ * @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);
+    spinlock_acquire(&server_spin);
+    if (server && port > 0)
+    {
+        server->port = port;
+    }
+    spinlock_release(&server_spin);
 }
 
-static struct {
-	char		*str;
-	unsigned int	bit;
+static struct
+{
+    char            *str;
+    unsigned int    bit;
 } ServerBits[] = {
-	{ "running", 		SERVER_RUNNING },
-	{ "master",		SERVER_MASTER },
-	{ "slave",		SERVER_SLAVE },
-	{ "synced",		SERVER_JOINED },
-	{ "ndb",		SERVER_NDB },
-	{ "maintenance",	SERVER_MAINT },
-	{ "maint",		SERVER_MAINT },
-	{ NULL,			0 }
+    { "running",     SERVER_RUNNING },
+    { "master",      SERVER_MASTER },
+    { "slave",       SERVER_SLAVE },
+    { "synced",      SERVER_JOINED },
+    { "ndb",         SERVER_NDB },
+    { "maintenance", SERVER_MAINT },
+    { "maint",       SERVER_MAINT },
+    { NULL,          0 }
 };
 
 /**
  * Map the server status bit
  *
- * @param str	String representation
+ * @param str   String representation
  * @return bit value or 0 on error
  */
 unsigned int
 server_map_status(char *str)
 {
-int i;
+    int i;
 
-	for (i = 0; ServerBits[i].str; i++)
-		if (!strcasecmp(str, ServerBits[i].str))
-			return ServerBits[i].bit;
-	return 0;
+    for (i = 0; ServerBits[i].str; i++)
+    {
+        if (!strcasecmp(str, ServerBits[i].str))
+        {
+            return ServerBits[i].bit;
+        }
+    }
+    return 0;
 }
 
 /**
diff --git a/server/include/server.h b/server/include/server.h
index 99b4e0555..c8c884b96 100644
--- a/server/include/server.h
+++ b/server/include/server.h
@@ -28,23 +28,23 @@
  * @verbatim
  * Revision History
  *
- * Date		Who			Description
- * 14/06/13	Mark Riddoch		Initial implementation
- * 21/06/13	Mark Riddoch		Addition of server status flags
- * 22/07/13	Mark Riddoch		Addition of JOINED status for Galera
- * 18/05/14	Mark Riddoch		Addition of unique_name field
- * 20/05/14	Massimiliano Pinto	Addition of server_string field
- * 20/05/14	Massimiliano Pinto	Addition of node_id field
- * 23/05/14	Massimiliano Pinto	Addition of rlag and node_ts fields
- * 03/06/14	Mark Riddoch		Addition of maintainance mode
- * 20/06/14	Massimiliano Pinto	Addition of master_id, depth, slaves fields
- * 26/06/14	Mark Riddoch		Adidtion of server parameters
- * 30/07/14	Massimiliano Pinto	Addition of NDB status for MySQL Cluster
- * 30/08/14	Massimiliano Pinto	Addition of SERVER_STALE_STATUS
- * 27/10/14	Massimiliano Pinto	Addition of SERVER_MASTER_STICKINESS
- * 19/02/15	Mark Riddoch		Addition of serverGetList
- * 01/06/15	Massimiliano Pinto	Addition of server_update_address/port
- * 19/06/15	Martin Brampton		Extra fields for persistent connections, CHK_SERVER
+ * Date         Who                     Description
+ * 14/06/13     Mark Riddoch            Initial implementation
+ * 21/06/13     Mark Riddoch            Addition of server status flags
+ * 22/07/13     Mark Riddoch            Addition of JOINED status for Galera
+ * 18/05/14     Mark Riddoch            Addition of unique_name field
+ * 20/05/14     Massimiliano Pinto      Addition of server_string field
+ * 20/05/14     Massimiliano Pinto      Addition of node_id field
+ * 23/05/14     Massimiliano Pinto      Addition of rlag and node_ts fields
+ * 03/06/14     Mark Riddoch            Addition of maintainance mode
+ * 20/06/14     Massimiliano Pinto      Addition of master_id, depth, slaves fields
+ * 26/06/14     Mark Riddoch            Adidtion of server parameters
+ * 30/07/14     Massimiliano Pinto      Addition of NDB status for MySQL Cluster
+ * 30/08/14     Massimiliano Pinto      Addition of SERVER_STALE_STATUS
+ * 27/10/14     Massimiliano Pinto      Addition of SERVER_MASTER_STICKINESS
+ * 19/02/15     Mark Riddoch            Addition of serverGetList
+ * 01/06/15     Massimiliano Pinto      Addition of server_update_address/port
+ * 19/06/15     Martin Brampton         Extra fields for persistent connections, CHK_SERVER
  *
  * @endverbatim
  */
@@ -55,22 +55,23 @@
  * The server parameters used for weighting routing decissions
  *
  */
-typedef struct server_params {
-	char		*name;		/**< Parameter name */
-	char		*value;		/**< Parameter value */
-	struct server_params
-			*next;		/**< Next Paramter in the linked list */
+typedef struct server_params
+{
+    char *name;                 /**< Parameter name */
+    char *value;                /**< Parameter value */
+    struct server_params *next; /**< Next Paramter in the linked list */
 } SERVER_PARAM;
 
 /**
  * The server statistics structure
  *
  */
-typedef struct {
-	int		n_connections;	/**< Number of connections */
-	int		n_current;	/**< Current connections */
-	int             n_current_ops;  /**< Current active operations */
-	int             n_persistent;  /**< Current persistent pool */
+typedef struct
+{
+    int n_connections; /**< Number of connections */
+    int n_current;     /**< Current connections */
+    int n_current_ops; /**< Current active operations */
+    int n_persistent;  /**< Current persistent pool */
 } SERVER_STATS;
 
 /**
@@ -81,35 +82,35 @@ typedef struct {
  */
 typedef struct server {
 #if defined(SS_DEBUG)
-        skygw_chk_t     server_chk_top;
+    skygw_chk_t     server_chk_top;
 #endif
-	SPINLOCK	lock;			/**< Common access lock */
-	char		*unique_name;	/**< Unique name for the server */
-	char		*name;		/**< Server name/IP address*/
-	unsigned short	port;		/**< Port to listen on */
-	char		*protocol;	/**< Protocol module to use */
-	unsigned int	status;		/**< Status flag bitmap for the server */
-	char		*monuser;	/**< User name to use to monitor the db */
-	char		*monpw;		/**< Password to use to monitor the db */
-	SERVER_STATS	stats;		/**< The server statistics */
-	struct	server	*next;		/**< Next server */
-	struct	server	*nextdb;	/**< Next server in list attached to a service */
-	char		*server_string;	/**< Server version string, i.e. MySQL server version */
-	long		node_id;	/**< Node id, server_id for M/S or local_index for Galera */
-	int		rlag;		/**< Replication Lag for Master / Slave replication */
-	unsigned long	node_ts;	/**< Last timestamp set from M/S monitor module */
-	SERVER_PARAM	*parameters;	/**< Parameters of a server that may be used to weight routing decisions */
-	long		master_id;	/**< Master server id of this node */
-	int		depth;		/**< Replication level in the tree */
-	long		*slaves;	/**< Slaves of this node */
-	bool            master_err_is_logged; /*< If node failed, this indicates whether it is logged */
-        DCB             *persistent;    /**< List of unused persistent connections to the server */
-        SPINLOCK        persistlock;   /**< Lock for adjusting the persistent connections list */
-        long            persistpoolmax; /**< Maximum size of persistent connections pool */
-        long            persistmaxtime; /**< Maximum number of seconds connection can live */
-        int             persistmax;     /**< Maximum pool size actually achieved since startup */
+    SPINLOCK       lock;           /**< Common access lock */
+    char           *unique_name;   /**< Unique name for the server */
+    char           *name;          /**< Server name/IP address*/
+    unsigned short port;           /**< Port to listen on */
+    char           *protocol;      /**< Protocol module to use */
+    unsigned int   status;         /**< Status flag bitmap for the server */
+    char           *monuser;       /**< User name to use to monitor the db */
+    char           *monpw;         /**< Password to use to monitor the db */
+    SERVER_STATS   stats;          /**< The server statistics */
+    struct  server *next;          /**< Next server */
+    struct  server *nextdb;        /**< Next server in list attached to a service */
+    char           *server_string; /**< Server version string, i.e. MySQL server version */
+    long           node_id;        /**< Node id, server_id for M/S or local_index for Galera */
+    int            rlag;           /**< Replication Lag for Master / Slave replication */
+    unsigned long  node_ts;        /**< Last timestamp set from M/S monitor module */
+    SERVER_PARAM   *parameters;    /**< Parameters of a server that may be used to weight routing decisions */
+    long           master_id;      /**< Master server id of this node */
+    int            depth;          /**< Replication level in the tree */
+    long           *slaves;        /**< Slaves of this node */
+    bool           master_err_is_logged; /*< If node failed, this indicates whether it is logged */
+    DCB            *persistent;    /**< List of unused persistent connections to the server */
+    SPINLOCK       persistlock;    /**< Lock for adjusting the persistent connections list */
+    long           persistpoolmax; /**< Maximum size of persistent connections pool */
+    long           persistmaxtime; /**< Maximum number of seconds connection can live */
+    int            persistmax;     /**< Maximum pool size actually achieved since startup */
 #if defined(SS_DEBUG)
-        skygw_chk_t     server_chk_tail;
+    skygw_chk_t    server_chk_tail;
 #endif
 } SERVER;
 
@@ -118,101 +119,105 @@ typedef struct server {
  *
  * These are a bitmap of attributes that may be applied to a server
  */
-#define	SERVER_RUNNING		0x0001	/**<< The server is up and running */
-#define SERVER_MASTER		0x0002	/**<< The server is a master, i.e. can handle writes */
-#define SERVER_SLAVE		0x0004	/**<< The server is a slave, i.e. can handle reads */
-#define SERVER_JOINED		0x0008	/**<< The server is joined in a Galera cluster */
-#define SERVER_NDB		0x0010	/**<< The server is part of a MySQL cluster setup */
-#define SERVER_MAINT		0x0020	/**<< Server is in maintenance mode */
-#define SERVER_SLAVE_OF_EXTERNAL_MASTER  0x0040	/**<< Server is slave of a Master outside the provided replication topology */
-#define SERVER_STALE_STATUS	0x0080	/**<< Server stale status, monitor didn't update it */
-#define SERVER_MASTER_STICKINESS	0x0100	/**<< Server Master stickiness */
-#define SERVER_AUTH_ERROR	0x1000	/**<< Authentication erorr from monitor */
+#define SERVER_RUNNING           0x0001  /**<< The server is up and running */
+#define SERVER_MASTER            0x0002  /**<< The server is a master, i.e. can handle writes */
+#define SERVER_SLAVE             0x0004  /**<< The server is a slave, i.e. can handle reads */
+#define SERVER_JOINED            0x0008  /**<< The server is joined in a Galera cluster */
+#define SERVER_NDB               0x0010  /**<< The server is part of a MySQL cluster setup */
+#define SERVER_MAINT             0x0020  /**<< Server is in maintenance mode */
+#define SERVER_SLAVE_OF_EXTERNAL_MASTER  0x0040 /**<< Server is slave of a Master outside
+                                                   the provided replication topology */
+#define SERVER_STALE_STATUS      0x0080  /**<< Server stale status, monitor didn't update it */
+#define SERVER_MASTER_STICKINESS 0x0100  /**<< Server Master stickiness */
+#define SERVER_AUTH_ERROR        0x1000  /**<< Authentication erorr from monitor */
 
 /**
  * Is the server running - the macro returns true if the server is marked as running
  * regardless of it's state as a master or slave
  */
-#define	SERVER_IS_RUNNING(server)	(((server)->status & (SERVER_RUNNING|SERVER_MAINT)) == SERVER_RUNNING)
+#define SERVER_IS_RUNNING(server) (((server)->status & (SERVER_RUNNING|SERVER_MAINT)) == SERVER_RUNNING)
 /**
  * Is the server marked as down - the macro returns true if the server is believed
  * to be inoperable.
  */
-#define	SERVER_IS_DOWN(server)		(((server)->status & SERVER_RUNNING) == 0)
+#define SERVER_IS_DOWN(server)          (((server)->status & SERVER_RUNNING) == 0)
 /**
  * Is the server a master? The server must be both running and marked as master
  * in order for the macro to return true
  */
-#define	SERVER_IS_MASTER(server) SRV_MASTER_STATUS((server)->status)
+#define SERVER_IS_MASTER(server) SRV_MASTER_STATUS((server)->status)
 
-#define SRV_MASTER_STATUS(status) ((status & 					\
-	(SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == 		\
-	(SERVER_RUNNING|SERVER_MASTER))
+#define SRV_MASTER_STATUS(status) ((status &                            \
+                                    (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == \
+                                   (SERVER_RUNNING|SERVER_MASTER))
 
 /**
  * Is the server valid candidate for root master. The server must be running,
  * marked as master and not have maintenance bit set.
  */
-#define	SERVER_IS_ROOT_MASTER(server) \
-(((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_MASTER))
+#define SERVER_IS_ROOT_MASTER(server)                                   \
+    (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_MASTER))
 
-			/**
+/**
  * Is the server a slave? The server must be both running and marked as a slave
  * in order for the macro to return true
  */
-#define	SERVER_IS_SLAVE(server)	\
-			(((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_SLAVE))
+#define SERVER_IS_SLAVE(server)                                         \
+    (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == \
+     (SERVER_RUNNING|SERVER_SLAVE))
 
 /**
  * Is the server joined Galera node? The server must be running and joined.
  */
-#define SERVER_IS_JOINED(server) \
-	(((server)->status & (SERVER_RUNNING|SERVER_JOINED|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_JOINED))
+#define SERVER_IS_JOINED(server)                                        \
+    (((server)->status & (SERVER_RUNNING|SERVER_JOINED|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_JOINED))
 
 /**
  * Is the server a SQL node in MySQL Cluster? The server must be running and with NDB status
  */
-#define SERVER_IS_NDB(server) \
-	(((server)->status & (SERVER_RUNNING|SERVER_NDB|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_NDB))
+#define SERVER_IS_NDB(server)                                           \
+    (((server)->status & (SERVER_RUNNING|SERVER_NDB|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_NDB))
 
 /**
  * Is the server in maintenance mode.
  */
-#define SERVER_IN_MAINT(server)		((server)->status & SERVER_MAINT)
+#define SERVER_IN_MAINT(server)         ((server)->status & SERVER_MAINT)
 
 /** server is not master, slave or joined */
-#define SERVER_NOT_IN_CLUSTER(s)        (((s)->status & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) == 0)
+#define SERVER_NOT_IN_CLUSTER(s) (((s)->status & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) == 0)
 
-#define SERVER_IS_IN_CLUSTER(s)         (((s)->status & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) != 0)
+#define SERVER_IS_IN_CLUSTER(s)  (((s)->status & (SERVER_MASTER|SERVER_SLAVE|SERVER_JOINED|SERVER_NDB)) != 0)
 
-#define SERVER_IS_RELAY_SERVER(server) \
-        (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE))
+#define SERVER_IS_RELAY_SERVER(server)                                  \
+    (((server)->status & (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE|SERVER_MAINT)) == \
+     (SERVER_RUNNING|SERVER_MASTER|SERVER_SLAVE))
 
-extern SERVER	*server_alloc(char *, char *, unsigned short);
-extern int	server_free(SERVER *);
-extern SERVER	*server_find_by_unique_name(char *);
-extern SERVER	*server_find(char *, unsigned short);
-extern void	printServer(SERVER *);
-extern void	printAllServers();
-extern void	dprintAllServers(DCB *);
-extern void	dprintAllServersJson(DCB *);
-extern void	dprintServer(DCB *, SERVER *);
-extern void     dprintPersistentDCBs(DCB *, SERVER *);
-extern void	dListServers(DCB *);
-extern char	*server_status(SERVER *);
-extern void     server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set);
-extern void	server_set_status(SERVER *, int);
-extern void	server_clear_status(SERVER *, int);
-extern void     server_transfer_status(SERVER *dest_server, SERVER *source_server);
-extern void	serverAddMonUser(SERVER *, char *, char *);
-extern void	serverAddParameter(SERVER *, char *, char *);
-extern char	*serverGetParameter(SERVER *, char *);
-extern void	server_update(SERVER *, char *, char *, char *);
-extern void     server_set_unique_name(SERVER *, char *);
-extern DCB      *server_get_persistent(SERVER *, char *, const char *);
-extern void	server_update_address(SERVER *, char *);
-extern void	server_update_port(SERVER *,  unsigned short);
-extern RESULTSET	*serverGetList();
+extern SERVER *server_alloc(char *, char *, unsigned short);
+extern int server_free(SERVER *);
+extern SERVER *server_find_by_unique_name(char *);
+extern SERVER *server_find(char *, unsigned short);
+extern void printServer(SERVER *);
+extern void printAllServers();
+extern void dprintAllServers(DCB *);
+extern void dprintAllServersJson(DCB *);
+extern void dprintServer(DCB *, SERVER *);
+extern void dprintPersistentDCBs(DCB *, SERVER *);
+extern void dListServers(DCB *);
+extern char *server_status(SERVER *);
+extern void server_clear_set_status(SERVER *server, int specified_bits, int bits_to_set);
+extern void server_set_status(SERVER *, int);
+extern void server_clear_status(SERVER *, int);
+extern void server_transfer_status(SERVER *dest_server, SERVER *source_server);
+extern void serverAddMonUser(SERVER *, char *, char *);
+extern void serverAddParameter(SERVER *, char *, char *);
+extern char *serverGetParameter(SERVER *, char *);
+extern void server_update(SERVER *, char *, char *, char *);
+extern void server_set_unique_name(SERVER *, char *);
+extern DCB  *server_get_persistent(SERVER *, char *, const char *);
+extern void server_update_address(SERVER *, char *);
+extern void server_update_port(SERVER *,  unsigned short);
+extern RESULTSET *serverGetList();
 extern unsigned int server_map_status(char *str);
 extern bool server_set_version_string(SERVER* server, const char* string);
+
 #endif