prestogres 0.1.0

data/pgpool2/watchdog/wd_if.c

@@ -0,0 +1,216 @@
+/*
+ * $Header$
+ *
+ * Handles watchdog connection, and protocol communication with pgpool-II
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL 
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2013	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.
+ *
+ */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <errno.h>
+#include "pool.h"
+#include "pool_config.h"
+#include "watchdog.h"
+#include "wd_ext.h"
+
+int wd_IP_up(void);
+int wd_IP_down(void);
+int wd_get_cmd(char * buf, char * cmd);
+static int exec_ifconfig(char * path,char * command);
+
+int
+wd_IP_up(void)
+{
+	int rtn = WD_OK;
+	char path[WD_MAX_PATH_LEN];
+	char cmd[128];
+
+	if (strlen(pool_config->delegate_IP) == 0)
+		return WD_NG;
+
+	if (WD_List->delegate_ip_flag == 0)
+	{
+		WD_List->delegate_ip_flag = 1;
+
+		wd_get_cmd(cmd,pool_config->if_up_cmd);
+		snprintf(path,sizeof(path),"%s/%s",pool_config->ifconfig_path,cmd);
+		rtn = exec_ifconfig(path,pool_config->if_up_cmd);
+
+		wd_get_cmd(cmd,pool_config->arping_cmd);
+		snprintf(path,sizeof(path),"%s/%s",pool_config->arping_path,cmd);
+		rtn = exec_ifconfig(path,pool_config->arping_cmd);
+	}
+	return rtn;
+}
+
+int
+wd_IP_down(void)
+{
+	int rtn = WD_OK;
+	char path[WD_MAX_PATH_LEN];
+	char cmd[128];
+	int i;
+
+	if (strlen(pool_config->delegate_IP) == 0)
+		return WD_NG;
+
+	if (WD_List->delegate_ip_flag == 1)
+	{
+		WD_List->delegate_ip_flag = 0;
+		wd_get_cmd(cmd,pool_config->if_down_cmd);
+		snprintf(path, sizeof(path), "%s/%s", pool_config->ifconfig_path, cmd);
+		rtn = exec_ifconfig(path,pool_config->if_down_cmd);
+
+		if (rtn == WD_OK)
+		{
+			for (i = 0; i < 3; i++)
+			{
+				if (wd_is_unused_ip(pool_config->delegate_IP))
+					break;
+			}
+
+			if (i >= 3)
+				rtn = WD_NG;
+		}
+
+		if (rtn == WD_OK)
+			pool_log("wd_IP_down: ifconfig down succeeded");
+		else
+			pool_error("wd_IP_down: ifconfig down failed");
+	}
+	else
+	{
+		pool_debug("wd_IP_down: not delegate IP holder");
+	}
+
+	return rtn;
+}
+
+int
+wd_get_cmd(char * buf, char * cmd)
+{
+	int i,j;
+	i = 0;
+	while(isspace(cmd[i]) != 0)
+	{
+		i++;
+	}
+	j = 0;
+	while(isspace(cmd[i]) == 0)
+	{
+		buf[j++] = cmd[i++];
+	}
+	buf[j] = '\0';
+	return strlen(buf);
+}
+
+static int
+exec_ifconfig(char * path,char * command)
+{
+	int pfd[2];
+	int status;
+	char * args[24];
+	int pid, i = 0;
+	char buf[256];
+	char *bp, *ep;
+
+	if (pipe(pfd) == -1)
+	{
+		pool_error("exec_ifconfig: pipe open error:%s",strerror(errno));
+		return WD_NG;
+	}
+	memset(buf,0,sizeof(buf));
+	strlcpy(buf,command,sizeof(buf));
+	bp = buf;
+	while (*bp == ' ')
+	{
+		bp ++;
+	}
+	while (*bp != '\0')
+	{
+		ep = strchr(bp,' ');
+		if (ep != NULL)
+		{
+			*ep = '\0';
+		}
+		if (!strncmp(bp,"$_IP_$",5))
+		{
+			args[i++] = pool_config->delegate_IP;
+		}
+		else
+		{
+			args[i++] = bp;
+		}
+		if (ep != NULL)
+		{
+			bp = ep +1;
+			while (*bp == ' ')
+			{
+				bp ++;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+	args[i++] = NULL;
+
+	pid = fork();
+	if (pid == 0)
+	{
+		close(STDOUT_FILENO);
+		dup2(pfd[1], STDOUT_FILENO);
+		close(pfd[0]);
+		status = execv(path,args);
+		exit(0);
+	}
+	else
+	{
+		close(pfd[1]);
+		for (;;)
+		{
+			int result;
+			result = wait(&status);
+			if (result < 0)
+			{
+				if (errno == EINTR)
+					continue;
+				return WD_NG;
+			}
+
+			if (WIFEXITED(status) == 0 || WEXITSTATUS(status) != 0)
+				return WD_NG;
+			else
+				break;
+		}
+		close(pfd[0]);
+	}
+	return WD_OK;
+}
+
+

data/pgpool2/watchdog/wd_init.c

@@ -0,0 +1,126 @@
+/*
+ * $Header$
+ *
+ * Handles watchdog connection, and protocol communication with pgpool-II
+ *
+ * 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.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "pool.h"
+#include "pool_config.h"
+#include "watchdog.h"
+#include "wd_ext.h"
+
+int wd_init(void);
+
+int
+wd_init(void)
+{
+	struct timeval tv;
+	WdInfo * p;
+
+	/* set startup time */
+	gettimeofday(&tv, NULL);
+
+	/* allocate watchdog list */
+	if (WD_List == NULL)
+	{
+		WD_List = pool_shared_memory_create(sizeof(WdInfo) * MAX_WATCHDOG_NUM);
+		if (WD_List == NULL)
+		{
+			pool_error("wd_init: failed to allocate watchdog list");
+			return WD_NG;
+		}
+		memset(WD_List, 0, sizeof(WdInfo) * MAX_WATCHDOG_NUM);
+	}
+
+	/* allocate node list */
+	if (WD_Node_List == NULL)
+	{
+		WD_Node_List = pool_shared_memory_create(sizeof(unsigned char) * MAX_NUM_BACKENDS);
+		if (WD_Node_List == NULL)
+		{
+			pool_error("wd_init: failed to allocate node list");
+			return WD_NG;
+		}
+		memset(WD_Node_List, 0, sizeof(unsigned char) * MAX_NUM_BACKENDS);
+	}
+
+	/* initialize interlock */
+	if (wd_init_interlock() != WD_OK)
+	{
+		pool_error("wd_init: wd_init_interlock failed");
+		return WD_NG;
+	}
+
+	/* set myself to watchdog list */
+	wd_set_wd_list(pool_config->wd_hostname, pool_config->port,
+	               pool_config->wd_port, pool_config->delegate_IP,
+				   &tv, WD_NORMAL);
+
+	/* set other pgpools to watchdog list */
+	wd_add_wd_list(pool_config->other_wd);
+
+	/* reset time value */
+	p = WD_List;
+	while (p->status != WD_END)
+	{
+		WD_TIME_INIT(p->hb_send_time);
+		WD_TIME_INIT(p->hb_last_recv_time);
+
+		p++;
+	}
+
+	/* check upper connection */
+	if (strlen(pool_config->trusted_servers) &&
+		wd_is_upper_ok(pool_config->trusted_servers) != WD_OK)
+	{
+		pool_error("wd_init: failed to connect trusted server");
+		return WD_NG;
+	}
+
+	/* send startup packet */
+	if (wd_startup() == WD_NG)
+	{
+		pool_error("wd_init: failed to start watchdog");
+		return WD_NG;
+	}
+
+	/* check existence of master pgpool */
+	if (wd_is_exist_master() == NULL)
+	{
+		if (strlen(pool_config->delegate_IP) != 0 &&
+		    !wd_is_unused_ip(pool_config->delegate_IP))
+		{
+			pool_error("wd_init: delegate_IP %s already exists", pool_config->delegate_IP);
+			return WD_NG;
+		}
+
+		/* escalate to delegate_IP holder */
+		wd_escalation();
+	}
+
+	pool_log("wd_init: start watchdog");
+	return WD_OK;	
+}

data/pgpool2/watchdog/wd_interlock.c

@@ -0,0 +1,347 @@
+/*
+ * $Header$
+ *
+ * Handles watchdog connection, and protocol communication with pgpool-II
+ *
+ * pgpool: a language independent connection pool server for PostgreSQL
+ * written by Tatsuo Ishii
+ *
+ * Copyright (c) 2003-2013	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.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include "pool.h"
+#include "pool_config.h"
+#include "watchdog.h"
+#include "wd_ext.h"
+
+static volatile bool * WD_Locks;
+
+int wd_init_interlock(void);
+void wd_start_interlock(bool by_health_check);
+void wd_end_interlock(void);
+void wd_leave_interlock(void);
+void wd_wait_for_lock(WD_LOCK_ID lock_id);
+bool wd_am_I_lock_holder(void);
+bool wd_is_locked(WD_LOCK_ID lock_id);
+void wd_set_lock(WD_LOCK_ID lock_id, bool value);
+int wd_unlock(WD_LOCK_ID lock_id);
+
+static void wd_update_lock_holder(void);
+static int wd_assume_lock_holder(void);
+static void wd_resign_lock_holder(void);
+static void wd_lock_all(void);
+static void wd_confirm_contactable(void);
+
+static void sleep_in_waiting(void);
+
+#define WD_INTERLOCK_WAIT_MSEC 500
+#define WD_INTERLOCK_TIMEOUT_SEC 10
+#define WD_INTERLOCK_WAIT_COUNT ((int) ((WD_INTERLOCK_TIMEOUT_SEC * 1000)/WD_INTERLOCK_WAIT_MSEC))
+
+/* initialize interlock */
+int
+wd_init_interlock(void)
+{
+	int alloc_size;
+
+	/* allocate WD_lock_holder */
+	if (WD_Locks == NULL)
+	{
+		alloc_size = sizeof(bool) * WD_MAX_LOCK_NUM;
+
+		WD_Locks = pool_shared_memory_create(alloc_size);
+		if (WD_Locks == NULL)
+		{
+			pool_error("wd_init_interlock: failed to allocate WD_Locks");
+			return WD_NG;
+		}
+		memset((void *)WD_Locks, 0, alloc_size);
+	}
+
+	return WD_OK;
+}
+
+/* notify to start interlocking */
+void wd_start_interlock(bool by_health_check)
+{
+	int count;
+	int node_id;
+
+	pool_log("wd_start_interlock: start interlocking");
+
+	/* confirm other pgpools are contactable */
+	wd_confirm_contactable();
+
+	/* lock all the resource */
+	wd_lock_all();
+
+	wd_set_interlocking(WD_MYSELF, true);
+	wd_send_packet_no(WD_START_INTERLOCK);
+
+	/* try to assume lock holder */
+	wd_assume_lock_holder();
+
+	/*
+	 * If it is due to DB down detection by healthcheck, send failover request
+	 * to other pgpools because detection of DB down on the others may be late.
+	 */
+	if (by_health_check && wd_am_I_lock_holder())
+	{
+		node_id = Req_info->node_id[0];
+		wd_degenerate_backend_set(&node_id, 1);
+	}
+
+	/* wait for all pgpools starting interlock */
+	count = WD_INTERLOCK_WAIT_COUNT;
+	while (wd_is_locked(WD_FAILOVER_START_LOCK))
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+		{
+			wd_set_lock_holder(WD_MYSELF, false);
+			return;
+		}
+
+		if (wd_am_I_lock_holder() && wd_are_interlocking_all())
+		{
+			wd_unlock(WD_FAILOVER_START_LOCK);
+		}
+
+		sleep_in_waiting();
+		if (--count < 0)
+		{
+			pool_error("wd_start_interlock: timed out");
+			break;
+		}
+	}
+}
+
+/* notify to end interlocking */
+void wd_end_interlock(void)
+{
+	int count;
+
+	pool_log("wd_end_interlock: end interlocking");
+
+	wd_set_interlocking(WD_MYSELF, false);
+	wd_send_packet_no(WD_END_INTERLOCK);
+
+	/* wait for all pgpools ending interlock */
+	count = WD_INTERLOCK_WAIT_COUNT;
+	while (wd_is_locked(WD_FAILOVER_END_LOCK))
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+		{
+			wd_set_lock_holder(WD_MYSELF, false);
+			break;
+		}
+
+		if (wd_am_I_lock_holder() && !wd_get_interlocking())
+		{
+			wd_unlock(WD_FAILOVER_END_LOCK);
+		}
+
+		sleep_in_waiting();
+		if (--count < 0)
+		{
+			pool_error("wd_end_interlock: timed out");
+			break;
+		}
+	}
+
+	if (wd_am_I_lock_holder())
+		wd_resign_lock_holder();
+
+	wd_clear_interlocking_info();
+}
+
+/* leave from interlocking by the wayside */
+void wd_leave_interlock(void)
+{
+	pool_log("wd_leave_interlock: leaving from interlocking");
+
+	if (wd_am_I_lock_holder())
+		wd_resign_lock_holder();
+
+	wd_end_interlock();
+}
+
+/* if lock holder return true otherwise false */
+bool wd_am_I_lock_holder(void)
+{
+	wd_update_lock_holder();
+	return WD_MYSELF->is_lock_holder;
+}
+
+/* waiting for the lock or to be lock holder */
+void wd_wait_for_lock(WD_LOCK_ID lock_id)
+{
+	int count;
+
+	count = WD_INTERLOCK_WAIT_COUNT;
+	while (wd_is_locked(lock_id))
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+		{
+			wd_set_lock_holder(WD_MYSELF, false);
+			return;
+		}
+
+		if (wd_am_I_lock_holder())
+			break;
+
+		sleep_in_waiting();
+		if (--count < 0)
+		{
+			pool_error("wd_wait_for_lock: timed out");
+			break;
+		}
+	}
+}
+
+/*
+ * assume lock holder
+ * return WD_OK if success.
+ */
+static int
+wd_assume_lock_holder(void)
+{
+	int rtn = WD_NG;
+
+	wd_set_lock_holder(WD_MYSELF, false);
+
+	if (WD_MYSELF->status == WD_DOWN)
+		return WD_NG;
+
+	/*
+	 * confirm contatable master exists;
+	 * If contactable master doesn't exists, WD_STAND_FOR_LOCK_HOLDER always
+	 * returns WD_OK, eventually multiple pgpools can become lock_holder.
+	 * Down of the host on which master pgpool was working is the case.
+	 */
+	while (!wd_is_contactable_master())
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+			return WD_NG;
+	}
+
+	/* I'm master and not lock holder, or I succeeded to become lock holder */
+	if ((WD_MYSELF->status == WD_MASTER && wd_get_lock_holder() == NULL) ||
+	    (wd_send_packet_no(WD_STAND_FOR_LOCK_HOLDER) == WD_OK))
+	{
+		if (wd_send_packet_no(WD_DECLARE_LOCK_HOLDER) == WD_OK)
+		{
+			wd_set_lock_holder(WD_MYSELF, true);
+			pool_log("wd_assume_lock_holder: become a new lock holder");
+			rtn = WD_OK;
+		}
+	}
+
+	return rtn;
+}
+
+/*
+ * update information of who's lock holder
+ * Note that a lock holder pgpool may go down accidentally during interlocking.
+ */
+static void
+wd_update_lock_holder(void)
+{
+	/* assume lock holder if not exist */
+	while (wd_get_lock_holder() == NULL)
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+			return;
+
+		wd_assume_lock_holder();
+	}
+}
+
+/* resign lock holder */
+static void
+wd_resign_lock_holder(void)
+{
+	wd_set_lock_holder(WD_MYSELF, false);
+	wd_send_packet_no(WD_RESIGN_LOCK_HOLDER);
+}
+
+/* returns true if lock_id is locked */
+bool
+wd_is_locked(WD_LOCK_ID lock_id)
+{
+	return WD_Locks[lock_id];
+}
+
+/* lock of unlock a resource */
+void
+wd_set_lock(WD_LOCK_ID lock_id, bool value)
+{
+	WD_Locks[lock_id] = value;
+}
+
+/* lock all the resource */
+static void
+wd_lock_all(void)
+{
+	int i;
+
+	for (i = 0; i < WD_MAX_LOCK_NUM; i++)
+		wd_set_lock(i, true);
+}
+
+/* unlock a resource */
+int
+wd_unlock(WD_LOCK_ID lock_id)
+{
+	int rtn;
+
+	wd_set_lock(lock_id, false);
+	rtn = wd_send_lock_packet(WD_UNLOCK_REQUEST, lock_id);
+	pool_debug("wd_unlock: send unlock request: %d", lock_id);
+
+	return rtn;
+}
+
+/* confirm other pgpools are contactable */
+static void
+wd_confirm_contactable(void)
+{
+	int count;
+
+	count = WD_INTERLOCK_WAIT_COUNT;
+	while (!wd_are_contactable_all())
+	{
+		if (WD_MYSELF->status == WD_DOWN)
+			return;
+
+		sleep_in_waiting();
+		if (--count < 0)
+		{
+			pool_error("wd_confirm_contactable: timed out");
+			break;
+		}
+	}
+}
+
+static void
+sleep_in_waiting(void)
+{
+	struct timeval t = {0, WD_INTERLOCK_WAIT_MSEC * 1000};
+	select(0, NULL, NULL, NULL, &t);
+}