Add monitor server handling & new process handling for master

include/responder.h

 
 void init_context();
 
+/**@brief Start a new pool_handler process
+ * @return the new PID or -1 if error */
+pid_t spawn_pool_handler();
+
 /**@brief The responder loop
  * @ingroup work_master_proc
  * The main function of the fcgi app fork child

src/main.c

 #include <string.h>
 #include <errno.h>
 #include <signal.h>
+#include <time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 extern pyfcgi_conf_t PyFCGI_conf;
 
 pid_t pool_handler_pid;
+pid_t monitor_serv_pid;
 
 void sighandler(int signum)
 {
 		kill(pool_handler_pid, SIGTERM);
 		waitpid(pool_handler_pid, &ret, 0);
 	}
+	if(monitor_serv_pid)
+	{
+		kill(monitor_serv_pid, SIGTERM);
+		waitpid(monitor_serv_pid, &ret, 0);
+	}
 	pyfcgi_log(LOG_INFO,
 		"Master process exiting.");
 	exit(0);
 
 int main(int argc, char **argv)
 {
+	int emerg_sleep = 3;
 	int child_ret;
-	unsigned int emerg_sleep = 3;
+	pid_t rpid;
 	struct sigaction act;
+	short fails, need_wait;
+	//Sleeping on waitpid WNOHANG
+	struct timespec tsleep;
+	char *child_name;
 
 	act.sa_handler = sighandler;
 	sigemptyset(&act.sa_mask);
 
 
 	pool_handler_pid = 0;
+	monitor_serv_pid = 0;
 	default_conf();
 	pyfcgi_name_sems(getpid()); //name semaphore using master proc PID
 
 
 	while(1)
 	{
-		pool_handler_pid = fork();
-		if(pool_handler_pid == -1)
+		if(PyFCGI_conf.mon_socket && !monitor_serv_pid)
+		{
+			monitor_serv_pid = pyfcgi_spawn_monitor();
+			if(monitor_serv_pid < 0)
+			{
+				fails = 1;
+				monitor_serv_pid = 0;
+			}
+		}
+		if(!pool_handler_pid)
+		{
+			pool_handler_pid = spawn_pool_handler();
+			if(pool_handler_pid < 0)
+			{
+				fails = 1;
+				pool_handler_pid = 0;
+			}
+		}
+		if(fails)
+		{
+			if(emerg_sleep > 600)
+			{
+				pyfcgi_log(LOG_EMERG, "Abording...");
+				exit(PYFCGI_FATAL);
+			}
+			fails = 0;
+			pyfcgi_log(LOG_WARNING, "Sleeping %ds",
+				emerg_sleep);
+			emerg_sleep *= 2;
+			continue;
+		}
+		else
+		{
+			emerg_sleep = 3;
+		}
+
+		need_wait = ((!PyFCGI_conf.mon_socket || monitor_serv_pid)
+			&& pool_handler_pid);
+		rpid = waitpid(0, &child_ret, need_wait?0:WNOHANG);
+		if(rpid == pool_handler_pid)
+		{
+			child_name = "Pool handler";
+			pool_handler_pid = 0;
+			if(!child_ret)
+			{
+				pyfcgi_log(LOG_NOTICE,
+					"Restarting main process after %d requests",
+					MAX_REQS);
+				continue;
+			}
+		}
+		else if(rpid == monitor_serv_pid)
 		{
-			// TODO : Error
-			pyfcgi_log(LOG_EMERG, "Failed to fork : '%s' sleeping %ds", strerror(errno), emerg_sleep);
-			sleep(emerg_sleep);
+			child_name = "Monitor server";
+			monitor_serv_pid = 0;
+		}
+		else if(rpid == 0 && !need_wait)
+		{
+			tsleep.tv_sec = 0;
+			tsleep.tv_nsec = 100000000;
+			nanosleep(&tsleep, NULL);
 			continue;
 		}
-		else if(!pool_handler_pid)
+		else if(rpid < 0)
 		{
-			responder_loop();
-			exit((unsigned char)-1);
+			pyfcgi_log(LOG_EMERG, "Unable to waitpid : %s",
+				strerror(errno));
+			exit(PYFCGI_FATAL);
 		}
-		waitpid(pool_handler_pid, &child_ret, 0);
-		pool_handler_pid = 0;
+		else
+		{
+			child_name = "Unknown child";
+			pyfcgi_log(LOG_WARNING,
+				"Unknown child (PID %d) exited...", rpid);
+		}
+
 		if(child_ret)
 		{
-			pyfcgi_log(LOG_ERR, "Responder loop function exits with error code '%d'",
-				WEXITSTATUS(child_ret));
+
+			pyfcgi_log(LOG_ERR, "%s exits with error code '%d'",
+				child_name, WEXITSTATUS(child_ret));
 			if(WIFSIGNALED(child_ret))
 			{
-				pyfcgi_log(LOG_ERR, "Responder loop function terminated by sig '%d'",
-					WTERMSIG(child_ret));
+				pyfcgi_log(LOG_ERR, "%s terminated by sig '%d'",
+					child_name, WTERMSIG(child_ret));
 			}
 		}
 		else
 		{
-			pyfcgi_log(LOG_NOTICE, "Restarting main process after %d requests", MAX_REQS);
+			pyfcgi_log(LOG_WARNING,
+				"%s exits with no error status 0",
+				child_name);
 		}
 	}
 

src/responder.c

 	exit(status);
 }
 
+pid_t spawn_pool_handler()
+{
+	pid_t res;
+
+	res = fork();
+	if(res < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Failed to fork pool_handler : %s",
+			strerror(errno));
+		return -1;
+	}
+	if(!res)
+	{
+		responder_loop();
+		exit((unsigned char)-1);
+	}
+	return res;
+}
+
 void init_context()
 {
 	PyFCGI_conf.context.pid = getpid();