server/utils/crossfire-loop.c

/* This is a watchdog pgrogram from Christian Stieber.  It is not an
 * officially supported piece of crossfire (I hope it works, but I am not
 * going to be spending time debugging problems in this piece of code).  The
 * idea is that it periodically sends/gets udp messages to the server - if
 * the server isn't responding, it kills it off and starts a new one.  There
 * is a bit more logic to it - From Christian:
 
The wrapper is just a hack. I'm using it on a Solaris machine, and it
seems to work fine. Notable features:
- uses the watchdog interface
- if the server crashes more than 10 times, with the time between
  successive crashes being less than 30 seconds, the wrapper terminates
  itself (to prevent bringing down the machine in case of startup problems)
- the server runs at nice 10

 * Note that the main advantage the watchdog has over just the simple
 * crossloop scripts is in the case of infinite loops.  For simple crashes,
 * the crossloop programs do a fine job.
 */

/*
 * Version 1
 */

/************************************************************************/
/*
 * Configuration options
 */

/* server executable */
#define CROSSFIRE_SERVER        "/usr/stud/stieber/bin/server"

/* directory to cd to before starting the server */
#define CROSSFIRE_TMPDIR        "/usr/stud/stieber/crossfire/tmp/"

/* if the server crashes more than CRASH_COUNT times, with less than
 * CRASH_INTERVAL seconds between two successive crashes, the loop
 * program is terminated. */
#define CRASH_COUNT             10
#define CRASH_INTERVAL          30

#define USE_WATCHDOG
#define ERROR_SLEEP             30

/************************************************************************/

#include <sys/unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>

/************************************************************************/

#ifdef USE_WATCHDOG
int Pipe[2];
#endif

/************************************************************************/

void SignalHandler(int Unused)

{
  if (write(Pipe[1],"",1)!=1)
    {
      perror("Pipe");
      exit(EXIT_FAILURE);
    }
}

/************************************************************************/

int main(void)

{
  int CrashCount;
#ifdef USE_WATCHDOG
  struct protoent *protoent;
  struct sockaddr_in insock;
  int fd;

  memset(&insock,0,sizeof(insock));

  if ((protoent=getprotobyname("udp"))==NULL)
    {
      perror("Can't get protobyname");
      return EXIT_FAILURE;
    }
  if ((fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1)
    {
      perror("Can't create socket");
      return EXIT_FAILURE;
    }
  insock.sin_family=AF_INET;
  insock.sin_port=htons((unsigned short)13325);
  if (bind(fd,(struct sockaddr *)&insock,sizeof(insock))==-1)
    {
      perror("Error on bind");
      return EXIT_FAILURE;
    }
#endif

  CrashCount=0;
  nice(10-nice(0));
  while (CrashCount<CRASH_COUNT)
    {
      time_t StartTime;
      time_t EndTime;
      pid_t Server;

      chdir(CROSSFIRE_TMPDIR);
      time(&StartTime);
#ifdef USE_WATCHDOG
      if (pipe(Pipe)==0)
        {
          void (*OldHandler)(int);

          OldHandler=signal(SIGCHLD,SignalHandler);
#endif
          switch (Server=fork())
            {
            case 0:
              execl(CROSSFIRE_SERVER,CROSSFIRE_SERVER,"-server",NULL);
              return EXIT_FAILURE;

            case -1:
              sleep(ERROR_SLEEP);
              break;

            default:
#ifdef USE_WATCHDOG
              while (1)
                {
                  fd_set Files;
                  struct timeval Timeout;
                  int Max;

                  FD_ZERO(&Files);
                  FD_SET(Pipe[0],&Files);
                  FD_SET(fd,&Files);
                  Timeout.tv_sec=5*60;
                  Timeout.tv_usec=0;
                  if (fd>Pipe[0])
                    {
                      Max=fd+1;
                    }
                  else
                    {
                      Max=Pipe[0]+1;
                    }
                  while (select(Max,&Files,NULL,NULL,&Timeout)==-1)
                    {
                      if (errno!=EINTR)
                        {
                          perror("Error on select");
                          return EXIT_FAILURE;
                        }
                    }
                  if (FD_ISSET(Pipe[0],&Files))
                    {
                      /* crash */
                      unlink("core");
                      waitpid(Server,NULL,0);
                      printf("Server crash!\n");
                      break;
                    }
                  else if (FD_ISSET(fd,&Files))
                    {
                      /* watchdog */
                      char t;

                      recv(fd,&t,1,0);
                    }
                  else
                    {
                      /* timeout */
                      printf("Watchdog timeout!\n");
                      if (kill(Server,SIGKILL)!=0)
                        {
                          perror("Error on kill");
                          return EXIT_FAILURE;
                        }
                    }
                }
#else
              waitpid(Server,NULL,0);
#endif
#ifdef USE_WATCHDOG
              signal(SIGCHLD,OldHandler);
#endif
              time(&EndTime);
              if (EndTime-StartTime<CRASH_INTERVAL)
                {
                  CrashCount++;
                }
              else
                {
                  CrashCount=0;
                }
              break;
            }
#ifdef USE_WATCHDOG
          close(Pipe[0]);
          close(Pipe[1]);
        }
      else
        {
          sleep(ERROR_SLEEP);
        }
#endif
    }
#ifdef USE_WATCHDOG
  close(fd);
#endif
  return 0;
}
Revision:	1.2
Committed:	Mon Mar 5 19:03:09 2007 UTC (17 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	major clenaup in utils/
#	Content
1	/* This is a watchdog pgrogram from Christian Stieber. It is not an
2	* officially supported piece of crossfire (I hope it works, but I am not
3	* going to be spending time debugging problems in this piece of code). The
4	* idea is that it periodically sends/gets udp messages to the server - if
5	* the server isn't responding, it kills it off and starts a new one. There
6	* is a bit more logic to it - From Christian:
7
8	The wrapper is just a hack. I'm using it on a Solaris machine, and it
9	seems to work fine. Notable features:
10	- uses the watchdog interface
11	- if the server crashes more than 10 times, with the time between
12	successive crashes being less than 30 seconds, the wrapper terminates
13	itself (to prevent bringing down the machine in case of startup problems)
14	- the server runs at nice 10
15
16	* Note that the main advantage the watchdog has over just the simple
17	* crossloop scripts is in the case of infinite loops. For simple crashes,
18	* the crossloop programs do a fine job.
19	*/
20
21	/*
22	* Version 1
23	*/
24
25	/************************************************************************/
26	/*
27	* Configuration options
28	*/
29
30	/* server executable */
31	#define CROSSFIRE_SERVER "/usr/stud/stieber/bin/server"
32
33	/* directory to cd to before starting the server */
34	#define CROSSFIRE_TMPDIR "/usr/stud/stieber/crossfire/tmp/"
35
36	/* if the server crashes more than CRASH_COUNT times, with less than
37	* CRASH_INTERVAL seconds between two successive crashes, the loop
38	* program is terminated. */
39	#define CRASH_COUNT 10
40	#define CRASH_INTERVAL 30
41
42	#define USE_WATCHDOG
43	#define ERROR_SLEEP 30
44
45	/************************************************************************/
46
47	#include <sys/unistd.h>
48	#include <sys/wait.h>
49	#include <stdlib.h>
50	#include <signal.h>
51	#include <stdio.h>
52	#include <unistd.h>
53	#include <sys/types.h>
54	#include <sys/socket.h>
55	#include <netinet/in.h>
56	#include <netdb.h>
57	#include <errno.h>
58
59	/************************************************************************/
60
61	#ifdef USE_WATCHDOG
62	int Pipe[2];
63	#endif
64
65	/************************************************************************/
66
67	void SignalHandler(int Unused)
68
69	{
70	if (write(Pipe[1],"",1)!=1)
71	{
72	perror("Pipe");
73	exit(EXIT_FAILURE);
74	}
75	}
76
77	/************************************************************************/
78
79	int main(void)
80
81	{
82	int CrashCount;
83	#ifdef USE_WATCHDOG
84	struct protoent *protoent;
85	struct sockaddr_in insock;
86	int fd;
87
88	memset(&insock,0,sizeof(insock));
89
90	if ((protoent=getprotobyname("udp"))==NULL)
91	{
92	perror("Can't get protobyname");
93	return EXIT_FAILURE;
94	}
95	if ((fd=socket(PF_INET, SOCK_DGRAM, protoent->p_proto))==-1)
96	{
97	perror("Can't create socket");
98	return EXIT_FAILURE;
99	}
100	insock.sin_family=AF_INET;
101	insock.sin_port=htons((unsigned short)13325);
102	if (bind(fd,(struct sockaddr *)&insock,sizeof(insock))==-1)
103	{
104	perror("Error on bind");
105	return EXIT_FAILURE;
106	}
107	#endif
108
109	CrashCount=0;
110	nice(10-nice(0));
111	while (CrashCount<CRASH_COUNT)
112	{
113	time_t StartTime;
114	time_t EndTime;
115	pid_t Server;
116
117	chdir(CROSSFIRE_TMPDIR);
118	time(&StartTime);
119	#ifdef USE_WATCHDOG
120	if (pipe(Pipe)==0)
121	{
122	void (*OldHandler)(int);
123
124	OldHandler=signal(SIGCHLD,SignalHandler);
125	#endif
126	switch (Server=fork())
127	{
128	case 0:
129	execl(CROSSFIRE_SERVER,CROSSFIRE_SERVER,"-server",NULL);
130	return EXIT_FAILURE;
131
132	case -1:
133	sleep(ERROR_SLEEP);
134	break;
135
136	default:
137	#ifdef USE_WATCHDOG
138	while (1)
139	{
140	fd_set Files;
141	struct timeval Timeout;
142	int Max;
143
144	FD_ZERO(&Files);
145	FD_SET(Pipe[0],&Files);
146	FD_SET(fd,&Files);
147	Timeout.tv_sec=5*60;
148	Timeout.tv_usec=0;
149	if (fd>Pipe[0])
150	{
151	Max=fd+1;
152	}
153	else
154	{
155	Max=Pipe[0]+1;
156	}
157	while (select(Max,&Files,NULL,NULL,&Timeout)==-1)
158	{
159	if (errno!=EINTR)
160	{
161	perror("Error on select");
162	return EXIT_FAILURE;
163	}
164	}
165	if (FD_ISSET(Pipe[0],&Files))
166	{
167	/* crash */
168	unlink("core");
169	waitpid(Server,NULL,0);
170	printf("Server crash!\n");
171	break;
172	}
173	else if (FD_ISSET(fd,&Files))
174	{
175	/* watchdog */
176	char t;
177
178	recv(fd,&t,1,0);
179	}
180	else
181	{
182	/* timeout */
183	printf("Watchdog timeout!\n");
184	if (kill(Server,SIGKILL)!=0)
185	{
186	perror("Error on kill");
187	return EXIT_FAILURE;
188	}
189	}
190	}
191	#else
192	waitpid(Server,NULL,0);
193	#endif
194	#ifdef USE_WATCHDOG
195	signal(SIGCHLD,OldHandler);
196	#endif
197	time(&EndTime);
198	if (EndTime-StartTime<CRASH_INTERVAL)
199	{
200	CrashCount++;
201	}
202	else
203	{
204	CrashCount=0;
205	}
206	break;
207	}
208	#ifdef USE_WATCHDOG
209	close(Pipe[0]);
210	close(Pipe[1]);
211	}
212	else
213	{
214	sleep(ERROR_SLEEP);
215	}
216	#endif
217	}
218	#ifdef USE_WATCHDOG
219	close(fd);
220	#endif
221	return 0;
222	}