Add worker count & load to stats : solve #24 solve #20 solve #19

include/responder.h

 /**@brief Handle watchdog alarm signal */
 void pool_wd_sighandler(int signum);
 
+/**@brief Update SHM data */
+void pyfcgi_pool_shm_update(int nworker);
+
 #endif

include/stats.h

 #define PYFCGI_STATS_SZ (900)
 
 typedef struct pyfcgi_stats_s pyfcgi_stats_t;
+typedef struct pyfcgi_stats_sample_s pyfcgi_stats_sample_t;
 typedef struct pyfcgi_stats_shm_s pyfcgi_stats_shm_t;
 
 #include "conf.h"
 #include "logger.h"
 
+/**@brief Stores data for stats on 15min (900s) */
+struct pyfcgi_stats_sample_s
+{
+	/**@brief One sample per seconds */
+	int samples[PYFCGI_STATS_SZ];
+	/**@brief Current sample */
+	int cur;
+};
+
 struct pyfcgi_stats_s
 {
 	/**@brief Request per seconds on 15 minutes */
-	int reqs[PYFCGI_STATS_SZ];
-	/**@brief Current request index */
-	int cur_req;
+	pyfcgi_stats_sample_t reqs;
+	/**@brief Worker count */
+	pyfcgi_stats_sample_t wcount;
+	/**@brief Load */
+	pyfcgi_stats_sample_t load;
 
 	/**@brief Repeating 1s timer sending SIGALRM */
 	timer_t timerid;
  * to remove this function... */
 const char *pyfcgi_stats_buff(const char **, size_t*);
 
+int pyfcgi_stats_get_shm(pyfcgi_stats_shm_t*);
+
 #endif
 

src/ipc.c

 	{
 		flag ^= IPC_SHMST;
 		PyFCGI_conf.shm.fd = shm_open(PyFCGI_conf.shm.name,
-			O_RDWR | O_CREAT | O_EXCL, 0770);
+			O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
 		if(PyFCGI_conf.shm.fd == -1)
 		{
 			err = errno;
 			pyfcgi_IPC_destroy(IPC_SHMST);
 			return -1;
 		}
+		memset(PyFCGI_conf.shm.ptr, 0, PyFCGI_conf.shm.len);
 	}
 	return res;
 }
 	if(flag & IPC_SHMST)
 	{
 		flag ^= IPC_SHMST;
-		PyFCGI_conf.shm.fd = shm_open(PyFCGI_conf.shm.name, O_RDONLY, 0);
+		PyFCGI_conf.shm.fd = shm_open(PyFCGI_conf.shm.name, O_RDONLY,
+			S_IRUSR | S_IWUSR);
 		if(PyFCGI_conf.shm.fd == -1)
 		{
 			err = errno;

src/responder.c

 		sleep(1);
 		clean_exit(PYFCGI_FATAL);
 	}
+	if(sem_post(PyFCGI_SEM(SEM_STATS).sem) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Unable to POST stat semaphore : %s",
+			strerror(errno));
+		clean_exit(PYFCGI_FATAL);
+	}
 }
 
 int responder_loop()
 	{
 		pyfcgi_wd_arm();
 		PyFCGI_conf.context.n_wrk = n_wrk;
+		pyfcgi_pool_shm_update(n_wrk);
 		if( (ret = waitpid(0, &status, WNOHANG)) )
 		{
 			if(ret < 0)
 	clean_exit(PYFCGI_TIMEOUT);
 	exit(PYFCGI_TIMEOUT);
 }
+
+
+void pyfcgi_pool_shm_update(int nworker)
+{
+	short retry;
+	int err;
+	pyfcgi_stats_shm_t *data;
+	struct timespec req;
+
+	req.tv_sec = 0;
+	req.tv_nsec = 10000000; //0.01s
+
+	retry = 0;
+	while(1)
+	{
+		if(sem_trywait(PyFCGI_SEM(SEM_STATS).sem) < 0)
+		{
+			err = errno;
+			if(err == EAGAIN)
+			{
+				if(retry >= 5)
+				{
+					pyfcgi_log(LOG_ALERT,
+						"Deadlock on SEM_STATS");
+						clean_exit(PYFCGI_FATAL);
+				}
+				nanosleep(&req, NULL);
+				continue;
+			}
+			pyfcgi_log(LOG_ALERT,
+				"Unable to wait stats semaphore : %s",
+				strerror(err));
+			clean_exit(PYFCGI_FATAL);
+		}
+		break;
+	}
+
+	data = (pyfcgi_stats_shm_t*)PyFCGI_conf.shm.ptr;
+	data->nworker = nworker;
+	if(sem_getvalue(PyFCGI_SEM(SEM_WSTATE).sem, &(data->pool_load)) < 0)
+	{
+		data->pool_load = -1;
+	}
+
+	if(sem_post(PyFCGI_SEM(SEM_STATS).sem) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Unable to post sem at shm update : %s",
+			strerror(errno));
+		clean_exit(PYFCGI_FATAL);
+	}
+}
+

src/stats.c

 
 static pyfcgi_stats_t pyfcgi_stats;
 
+static void pyfcgi_stats_add_sample(pyfcgi_stats_sample_t* samples, int sample)
+{
+	samples->samples[samples->cur] = sample;
+	samples->cur++;
+}
+
 int pyfcgi_stats_init()
 {
 	struct sigaction act;
 {
 	int ret;
 	pyfcgi_stats_t *stats;
+	pyfcgi_stats_shm_t shm_data;
 
 	stats = &pyfcgi_stats;
 
-	stats->reqs[stats->cur_req] = 0;
+	stats->reqs.samples[stats->reqs.cur] = 0;
 	while( !(ret = sem_trywait(PyFCGI_SEM(SEM_WREQS).sem)) )
 	{
-		stats->reqs[stats->cur_req]++;
+		stats->reqs.samples[stats->reqs.cur]++;
+	}
+	stats->reqs.cur++;
+	stats->reqs.cur %= PYFCGI_STATS_SZ;
+
+	if(pyfcgi_stats_get_shm(&shm_data) < 0)
+	{
+		kill(getpid(), SIGTERM);
 	}
-	pyfcgi_log(LOG_DEBUG, "s#%d %d req/s", pyfcgi_stats.cur_req,
-		pyfcgi_stats.reqs[stats->cur_req]);
-	stats->cur_req++;
-	stats->cur_req %= PYFCGI_STATS_SZ;
+
+	pyfcgi_stats_add_sample(&(stats->wcount), shm_data.nworker);
+	pyfcgi_stats_add_sample(&(stats->load),
+		shm_data.nworker - shm_data.pool_load);
 
 	return;
 }
 
 	do
 	{
-		ret = pyfcgi_stats_avg(pyfcgi_stats.reqs,
-			&(pyfcgi_stats.cur_req), &last_rs, avgs);
+		last_rs = pyfcgi_stats.reqs.cur;
+		ret = pyfcgi_stats_avg(pyfcgi_stats.reqs.samples,
+			&(pyfcgi_stats.reqs.cur), &last_rs, avgs);
 	} while(ret < 0 && errno == EINTR);
+
 	pyfcgi_stats_buffprintf("Requests stats :\n1s:%dr/s 1m:%.2fr/s 5m:%.2fr/s 10m:%.2fr/s 15m:%.2fr/s\n",
 		last_rs, avgs[0], avgs[1], avgs[2], avgs[3]);
+
+	// Worker counter stats formating
+	do
+	{
+		last_rs = pyfcgi_stats.wcount.cur;
+		pyfcgi_stats_avg(pyfcgi_stats.wcount.samples,&(pyfcgi_stats.wcount.cur),
+			&(last_rs), avgs);
+	} while(ret < 0 && errno == EINTR);
+
+	pyfcgi_stats_buffprintf("Worker count :\n1s:%d 1m:%.2f 5m:%.2f 10m:%.2f 15m:%.2f\n",
+		last_rs, avgs[0], avgs[1], avgs[2], avgs[3]);
+
+	// Load stats formating
+	do
+	{
+		last_rs = pyfcgi_stats.load.cur;
+		pyfcgi_stats_avg(pyfcgi_stats.load.samples,&(pyfcgi_stats.load.cur),
+			&(last_rs), avgs);
+	} while(ret < 0 && errno == EINTR);
+
+	pyfcgi_stats_buffprintf("Load average :\n1s:%d 1m:%.2f 5m:%.2f 10m:%.2f 15m:%.2f\n",
+		last_rs, avgs[0], avgs[1], avgs[2], avgs[3]);
+
+
 	return pyfcgi_stats.buff_ptr;
 }
 
 		if(i<=15*60) { r15 += rtmp; }
 		stmp = cur;
 	}
+	r15 += (long double)stmp / 60;
 	//Restore interrupt/ALARM ??
 	r5 /= 5;
 	r10 /= 10;
 	*len = pyfcgi_stats.buff_ptr;
 	return *buff;
 }
+
+
+int pyfcgi_stats_get_shm(pyfcgi_stats_shm_t *res)
+{
+	short retry;
+	int err;
+	struct timespec req;
+
+	req.tv_sec = 0;
+	req.tv_nsec = 10000000; //0.01s
+
+	retry = 0;
+
+	while(1)
+	{
+		if(sem_trywait(PyFCGI_SEM(SEM_STATS).sem) < 0)
+		{
+			err = errno;
+			if(err == EAGAIN)
+			{
+				if(retry >= 5)
+				{
+					pyfcgi_log(LOG_ALERT,
+						"Deadlock on SEM_STATS");
+					return -1;
+				}
+				nanosleep(&req, NULL);
+				continue;
+			}
+			pyfcgi_log(LOG_ALERT,
+				"Unable to wait stats semaphore : %s",
+				strerror(err));
+			return -1;
+		}
+		break;
+	}
+
+	*res = *(pyfcgi_stats_shm_t*)PyFCGI_conf.shm.ptr;
+
+	if(sem_post(PyFCGI_SEM(SEM_STATS).sem) < 0)
+	{
+		pyfcgi_log(LOG_ALERT, "Unable to post sem at shm update : %s",
+			strerror(errno));
+		return -1;
+	}
+	return 0;
+}
+
+