prestogres 0.1.0

data/pgpool2/watchdog/watchdog.h

@@ -0,0 +1,209 @@
+/* -*-pgsql-c-*- */
+/*
+ *
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2012	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * watchdog.h.: watchdog definition header file
+ *
+ */
+
+#ifndef WATCHDOG_H
+#define WATCHDOG_H
+
+#include <sys/time.h>
+#include "libpq-fe.h"
+
+#include "md5.h"
+
+#define WD_MAX_HOST_NAMELEN (128)
+#define WD_MAX_PATH_LEN (128)
+#define MAX_WATCHDOG_NUM (128)
+#define WD_SEND_TIMEOUT (1)
+#define WD_MAX_IF_NUM (256)
+#define WD_MAX_IF_NAME_LEN (16)
+
+#define WD_INFO(wd_id) (pool_config->other_wd->wd_info[(wd_id)])
+#define WD_HB_IF(if_id) (pool_config->hb_if[(if_id)])
+
+#define WD_MYSELF (WD_List)
+
+#define WD_NG (0)
+#define WD_OK (1)
+
+#define WD_MAX_PACKET_STRING (256)
+
+#define WD_TIME_INIT(tv)      ((tv).tv_sec = (tv).tv_usec = 0)
+#define WD_TIME_ISSET(tv)     ((tv).tv_sec || (tv).tv_usec)
+#define WD_TIME_BEFORE(a,b)   (((a).tv_sec == (b).tv_sec) ? \
+                               ((a).tv_usec < (b).tv_usec) : \
+                               ((a).tv_sec < (b).tv_sec))
+#define WD_TIME_DIFF_SEC(a,b) (int)(((a).tv_sec - (b).tv_sec) + \
+                                    ((a).tv_usec - (b).tv_usec) / 1000000.0)
+
+/*
+ * packet number of watchdog negotiation
+ */
+typedef enum {
+
+	/* normal packet */
+	WD_INVALID = 0,				/* invalid packet no */
+	WD_INFO_REQ,				/* information request */
+	WD_ADD_REQ,					/* add request into the watchdog list */
+	WD_ADD_ACCEPT,				/* accept the add request */
+	WD_ADD_REJECT,				/* reject the add request */
+	WD_STAND_FOR_MASTER,		/* announce candidacy */
+	WD_VOTE_YOU,				/* agree to the candidacy */
+	WD_MASTER_EXIST,			/* disagree to the candidacy */
+	WD_DECLARE_NEW_MASTER,		/* announce assumption */
+	WD_STAND_FOR_LOCK_HOLDER,	/* announce candidacy for lock holder */
+	WD_LOCK_HOLDER_EXIST,		/* reject the assumption for lock holder */
+	WD_DECLARE_LOCK_HOLDER,		/* announce to assume lock holder */
+	WD_RESIGN_LOCK_HOLDER,		/* announce to resign lock holder */
+	WD_START_INTERLOCK,			/* announce to start interlocking */
+	WD_END_INTERLOCK,			/* announce to end interlocking */
+	WD_SERVER_DOWN,				/* announce server down */
+	WD_AUTH_FAILED,				/* fail answer to authentication */
+	WD_READY,					/* answer to the announce */
+
+	/* node packet */
+	WD_START_RECOVERY,		/* announce start online recovery */
+	WD_END_RECOVERY,		/* announce end online recovery */
+	WD_FAILBACK_REQUEST,	/* announce failback request */
+	WD_DEGENERATE_BACKEND,	/* announce degenerate backend */
+	WD_PROMOTE_BACKEND,		/* announce promote backend */
+	WD_NODE_READY,			/* answer to the node announce */
+	WD_NODE_FAILED,			/* fail answer to the node announce */
+
+	/* lock packet */
+	WD_UNLOCK_REQUEST,		/* announce to unlock command */
+	WD_LOCK_READY,			/* answer to the lock announce */
+	WD_LOCK_FAILED			/* fail answer to the lock announce */
+
+} WD_PACKET_NO;
+
+/*
+ * watchdog status
+ */
+typedef enum {
+	WD_END = 0,
+	WD_INIT,
+	WD_NORMAL,
+	WD_MASTER,
+	WD_DOWN
+} WD_STATUS;
+
+/*
+ * watchdog locks
+ */
+typedef enum {
+	WD_FAILOVER_START_LOCK = 0,
+	WD_FAILOVER_END_LOCK,
+	WD_FAILOVER_COMMAND_LOCK,
+	WD_FAILBACK_COMMAND_LOCK,
+	WD_FOLLOW_MASTER_COMMAND_LOCK,
+	WD_MAX_LOCK_NUM
+} WD_LOCK_ID;
+
+/*
+ * watchdog list
+ */
+typedef struct WdInfo {
+	WD_STATUS status;						/* status */
+	struct timeval tv;						/* startup time value */
+	char hostname[WD_MAX_HOST_NAMELEN];		/* host name */
+	int pgpool_port;						/* pgpool port */
+	int wd_port;							/* watchdog port */
+	int life;								/* life point */
+	char delegate_ip[WD_MAX_HOST_NAMELEN];	/* delegate IP */
+	int delegate_ip_flag;					/* delegate IP flag */
+	struct timeval hb_send_time; 			/* send time */
+	struct timeval hb_last_recv_time; 		/* recv time */
+	bool is_lock_holder;					/* lock holder flag */
+	bool in_interlocking;					/* interlocking is in progress */
+	bool is_contactable;					/* able to create socket and connection */
+} WdInfo;
+
+typedef struct {
+	int node_id_set[MAX_NUM_BACKENDS];	/* node sets */
+	int node_num;						/* node number */
+} WdNodeInfo;
+
+typedef struct {
+	WD_LOCK_ID lock_id;
+} WdLockInfo;
+
+typedef union {
+	WdInfo wd_info;
+	WdNodeInfo wd_node_info;
+	WdLockInfo wd_lock_info;
+} WD_PACKET_BODY;
+
+typedef struct {
+	char addr[WD_MAX_HOST_NAMELEN];
+	char if_name[WD_MAX_IF_NAME_LEN];
+	int dest_port;
+} WdHbIf;
+
+typedef struct {
+	int num_wd;		/* number of watchdogs */
+	WdInfo wd_info[MAX_WATCHDOG_NUM];
+} WdDesc;
+
+/*
+ * negotiation packet
+ */
+typedef struct {
+	WD_PACKET_NO packet_no;	/* packet number */
+	WD_PACKET_BODY wd_body;			/* watchdog information */
+	struct timeval send_time;
+	char hash[(MD5_PASSWD_LEN+1)*2];
+} WdPacket;
+
+/*
+ * thread argument for watchdog negotiation
+ */
+typedef struct {
+	int sock;			/* socket */
+	WdInfo * target;	/* target watchdog information */
+	WdPacket * packet;	/* packet data */
+} WdPacketThreadArg;
+
+/*
+ * heartbeat packet
+ */
+typedef struct {
+	char from[WD_MAX_HOST_NAMELEN];
+	int from_pgpool_port;
+	struct timeval send_time;
+	WD_STATUS status;
+	char hash[(MD5_PASSWD_LEN+1)*2];
+} WdHbPacket;
+
+/*
+ * thread argument for lifecheck of pgpool
+ */
+typedef struct {
+	PGconn * conn;	/* PGconn */
+	int retry;		/* retry times (not used?)*/
+} WdPgpoolThreadArg;
+
+extern WdInfo * WD_List;
+extern unsigned char * WD_Node_List;
+
+#endif /* WATCHDOG_H */

data/pgpool2/watchdog/wd_child.c

@@ -0,0 +1,444 @@
+/* -*-pgsql-c-*- */
+/*
+ * $Header$
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2012	PgPool Global Development Group
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of the
+ * author not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission. The author makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * child.c: child process main
+ *
+ */
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <signal.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include "pool.h"
+#include "watchdog.h"
+#include "pool_config.h"
+#include "wd_ext.h"
+
+pid_t wd_child(int fork_wait_time);
+static void wd_child_exit(int exit_signo);
+static int wd_send_response(int sock, WdPacket * recv_pack);
+static void wd_node_request_signal(WD_PACKET_NO packet_no, WdNodeInfo *node);
+
+pid_t
+wd_child(int fork_wait_time)
+{
+	int sock;
+	int fd;
+	int rtn;
+	pid_t pid = 0;
+
+	pid = fork();
+	if (pid != 0)
+	{
+		if (pid == -1)
+			pool_error("wd_child: fork() failed.");
+
+		return pid;
+	}
+
+	if (fork_wait_time > 0)
+	{
+		sleep(fork_wait_time);
+	}
+
+	myargv = save_ps_display_args(myargc, myargv);
+
+	POOL_SETMASK(&UnBlockSig);
+
+	signal(SIGTERM, wd_child_exit);
+	signal(SIGINT, wd_child_exit);
+	signal(SIGQUIT, wd_child_exit);
+	signal(SIGCHLD, SIG_IGN);
+	signal(SIGHUP, SIG_IGN);
+	signal(SIGUSR1, SIG_IGN);
+	signal(SIGUSR2, SIG_IGN);
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGALRM, SIG_IGN);
+
+	init_ps_display("", "", "", "");
+
+	if (WD_List == NULL)
+	{
+		/* memory allocate is not ready */
+		wd_child_exit(15);
+	}
+
+	sock = wd_create_recv_socket(WD_MYSELF->wd_port);
+
+	if (sock < 0)
+	{
+		/* socket create failed */
+		wd_child_exit(15);
+	}
+
+	set_ps_display("watchdog", false);
+
+	/* child loop */
+	for(;;)
+	{
+		WdPacket buf;
+		fd = wd_accept(sock);
+		if (fd < 0)
+		{
+			continue;
+		}
+		rtn = wd_recv_packet(fd, &buf);
+		if (rtn == WD_OK)
+		{
+			wd_send_response(fd, &buf);
+		}
+		close(fd);
+	}
+	return pid;
+}
+
+static void
+wd_child_exit(int exit_signo)
+{
+	sigset_t mask;
+
+	sigemptyset(&mask);
+	sigaddset(&mask, SIGTERM);
+	sigaddset(&mask, SIGINT);
+	sigaddset(&mask, SIGQUIT);
+	sigaddset(&mask, SIGCHLD);
+	sigprocmask(SIG_BLOCK, &mask, NULL);
+
+	exit(0);
+}
+
+static int
+wd_send_response(int sock, WdPacket * recv_pack)
+{
+	int rtn = WD_NG;
+	WdInfo * p, *q;
+	WdNodeInfo * node;
+	WdLockInfo * lock;
+	WdPacket send_packet;
+	struct timeval tv;
+	char pack_str[WD_MAX_PACKET_STRING];
+	int pack_str_len;
+	char hash[(MD5_PASSWD_LEN+1)*2];
+	bool is_node_packet = false;
+
+	if (recv_pack == NULL)
+	{
+		return rtn;
+	}
+	memset(&send_packet, 0, sizeof(WdPacket));
+	p = &(recv_pack->wd_body.wd_info);
+
+	/* authentication */
+	if (strlen(pool_config->wd_authkey))
+	{
+		/* calculate hash from packet */
+		pack_str_len = wd_packet_to_string(recv_pack, pack_str, sizeof(pack_str));
+		wd_calc_hash(pack_str, pack_str_len, hash);
+
+		if (strcmp(recv_pack->hash, hash))
+		{
+			pool_log("wd_send_response: watchdog authentication failed");
+			rtn = wd_authentication_failed(sock);
+			return rtn;
+		}
+	}
+
+	/* set response packet no */
+	switch (recv_pack->packet_no)
+	{
+		/* information request */
+		case WD_INFO_REQ:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* add request into the watchdog list */
+		case WD_ADD_REQ:
+			p = &(recv_pack->wd_body.wd_info);
+			if (wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port,
+			                   p->delegate_ip, &(p->tv), p->status) > 0)
+			{
+				pool_log("wd_send_response: receive add request from %s:%d and accept it",
+				         p->hostname, p->pgpool_port);
+				send_packet.packet_no = WD_ADD_ACCEPT;
+			}
+			else
+			{
+				pool_log("wd_send_response: receive add request from %s:%d and reject it",
+				         p->hostname, p->pgpool_port);
+				send_packet.packet_no = WD_ADD_REJECT;
+			}
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce candidacy to be the new master */
+		case WD_STAND_FOR_MASTER:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			/* check exist master */
+			if ((q = wd_is_alive_master()) != NULL)
+			{
+				/* vote against the candidate */
+				send_packet.packet_no = WD_MASTER_EXIST;
+				memcpy(&(send_packet.wd_body.wd_info), q, sizeof(WdInfo));
+
+				pool_log("wd_send_response: WD_STAND_FOR_MASTER received, and voting against %s:%d",
+				         p->hostname, p->pgpool_port);
+			}
+			else
+			{
+				if (WD_MYSELF->tv.tv_sec <= p->tv.tv_sec )
+				{
+					memcpy(&tv,&(p->tv),sizeof(struct timeval));
+					tv.tv_sec += 1;
+					wd_set_myself(&tv, WD_NORMAL);
+				}
+				/* vote for the candidate */
+				send_packet.packet_no = WD_VOTE_YOU;
+				memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+
+				pool_log("wd_send_response: WD_STAND_FOR_MASTER received, and voting for %s:%d",
+				         p->hostname, p->pgpool_port);
+			}
+			break;
+
+		/* announce assumption to be the new master */
+		case WD_DECLARE_NEW_MASTER:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			if (WD_MYSELF->status == WD_MASTER)
+			{
+				/* resign master server */
+				pool_log("wd_send_response: WD_DECLARE_NEW_MASTER received and resign master server");
+				if (strlen(pool_config->delegate_IP) != 0)
+					wd_IP_down();
+				wd_set_myself(NULL, WD_NORMAL);
+			}
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce to assume lock holder */
+		case WD_STAND_FOR_LOCK_HOLDER:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			/* only master handles lock holder assignment */
+			if (WD_MYSELF->status == WD_MASTER)
+			{
+				/* if lock holder exists yet */
+				if (wd_get_lock_holder() != NULL)
+				{
+					pool_log("wd_send_response: WD_STAND_FOR_LOCK_HOLDER received but lock holder exists already");
+					send_packet.packet_no = WD_LOCK_HOLDER_EXIST;
+				}
+				else
+				{
+					pool_log("wd_send_response: WD_STAND_FOR_LOCK_HOLDER received it");
+					wd_set_lock_holder(p, true);
+					send_packet.packet_no = WD_READY;
+				}
+			}
+			else
+			{
+				send_packet.packet_no = WD_READY;
+			}
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce to assume lock holder */
+		case WD_DECLARE_LOCK_HOLDER:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			if (WD_MYSELF->is_lock_holder)
+			{
+				pool_log("wd_send_response: WD_DECLARE_LOCK_HOLDER received but lock holder exists already");
+				send_packet.packet_no = WD_LOCK_HOLDER_EXIST;
+			}
+			else
+			{
+				wd_set_lock_holder(p, true);
+				send_packet.packet_no = WD_READY;
+			}
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce to resign lock holder */
+		case WD_RESIGN_LOCK_HOLDER:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			wd_set_lock_holder(p, false);
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce to start interlocking */
+		case WD_START_INTERLOCK:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			wd_set_interlocking(p, true);
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce to end interlocking */
+		case WD_END_INTERLOCK:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), p->status);
+			wd_set_interlocking(p, false);
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+
+		/* announce that server is down */
+		case WD_SERVER_DOWN:
+			p = &(recv_pack->wd_body.wd_info);
+			wd_set_wd_list(p->hostname, p->pgpool_port, p->wd_port, p->delegate_ip, &(p->tv), WD_DOWN);
+			send_packet.packet_no = WD_READY;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			if (wd_am_I_oldest() == WD_OK && WD_MYSELF->status != WD_MASTER)
+			{
+				wd_escalation();
+			}
+			break;
+
+		/* announce start online recovery */
+		case WD_START_RECOVERY:
+			if (*InRecovery != RECOVERY_INIT)
+			{
+				send_packet.packet_no = WD_NODE_FAILED;
+			}
+			else
+			{
+				send_packet.packet_no = WD_NODE_READY;
+				*InRecovery = RECOVERY_ONLINE;
+				if (wait_connection_closed() != 0)
+				{
+					send_packet.packet_no = WD_NODE_FAILED;
+				}
+			}
+			break;
+
+		/* announce end online recovery */
+		case WD_END_RECOVERY:
+			send_packet.packet_no = WD_NODE_READY;
+			*InRecovery = RECOVERY_INIT;
+			kill(wd_ppid, SIGUSR2);
+			break;
+
+		/* announce failback request */
+		case WD_FAILBACK_REQUEST:
+			if (Req_info->switching)
+			{
+				pool_log("wd_send_response: failback request from other pgpool is canceled because it's while switching");
+				send_packet.packet_no = WD_NODE_FAILED;
+			}
+			else
+			{
+				node = &(recv_pack->wd_body.wd_node_info);
+				wd_set_node_mask(WD_FAILBACK_REQUEST,node->node_id_set,node->node_num);
+				is_node_packet = true;
+				send_packet.packet_no = WD_NODE_READY;
+			}
+			break;
+
+		/* announce degenerate backend */
+		case WD_DEGENERATE_BACKEND:
+			if (Req_info->switching)
+			{
+				pool_log("wd_send_response: failover request from other pgpool is canceled because it's while switching");
+				send_packet.packet_no = WD_NODE_FAILED;
+			}
+			else
+			{
+				node = &(recv_pack->wd_body.wd_node_info);
+				wd_set_node_mask(WD_DEGENERATE_BACKEND,node->node_id_set, node->node_num);
+				is_node_packet = true;
+				send_packet.packet_no = WD_NODE_READY;
+			}
+			break;
+
+		/* announce promote backend */
+		case WD_PROMOTE_BACKEND:
+			if (Req_info->switching)
+			{
+				pool_log("wd_send_response: promote request from other pgpool is canceled because it's while switching");
+				send_packet.packet_no = WD_NODE_FAILED;
+			}
+			else
+			{
+				node = &(recv_pack->wd_body.wd_node_info);
+				wd_set_node_mask(WD_PROMOTE_BACKEND,node->node_id_set, node->node_num);
+				is_node_packet = true;
+				send_packet.packet_no = WD_NODE_READY;
+			}
+			break;
+
+		/* announce to unlock command */
+		case WD_UNLOCK_REQUEST:
+			lock = &(recv_pack->wd_body.wd_lock_info);
+			wd_set_lock(lock->lock_id, false);
+			send_packet.packet_no = WD_LOCK_READY;
+			break;
+
+		default:
+			send_packet.packet_no = WD_INVALID;
+			memcpy(&(send_packet.wd_body.wd_info), WD_MYSELF, sizeof(WdInfo));
+			break;
+	}
+
+	/* send response packet */
+	rtn = wd_send_packet(sock, &send_packet);
+
+	/* send node request signal.
+	 * wd_node_request_signal() uses a semaphore lock internally, so should be
+	 * called after sending a response packet to prevent dead lock.
+	 */
+	if (is_node_packet)
+		wd_node_request_signal(recv_pack->packet_no, node);
+
+	return rtn;
+}
+
+/* send node request signal for other pgpool*/
+static void
+wd_node_request_signal(WD_PACKET_NO packet_no, WdNodeInfo *node)
+{
+	switch (packet_no)
+	{
+		case WD_FAILBACK_REQUEST:
+			send_failback_request(node->node_id_set[0]);
+			break;
+		case WD_DEGENERATE_BACKEND:
+			degenerate_backend_set(node->node_id_set, node->node_num);
+			break;
+		case WD_PROMOTE_BACKEND:
+			promote_backend(node->node_id_set[0]);
+			break;
+		default:
+			pool_error("wd_node_request_signal: unknown packet number");
+			break;
+	}
+}