fixed a bug in #ifdef for pump/web3 spotted by riccardo

.hgtags

@@ -37,3 +37,4 @@ fb168b0b86169219aa9b8e40f0caa6297cf34dbc 0.9.9-rc1
 4e4e781ef89ac33e71a7e92741d54549240ed156 1.0-rc3
 24f7e260ea345c2cd73e2fd8191dddbd1b039062 1.0-rc4
 043ba93dd69cf6924e98db3cb9a8759cce997367 1.0-rc5
+a2b8f25fd17ed7424d1470a287d0b3144d2a12c8 1.0-rc6

CONTRIBUTORS

@@ -14,3 +14,4 @@ Cal Leeming, Simplicity Media Ltd
 Luigi Scarso
 Corey Farwell
 Charles Duffy
+Lukas Lalinsky

buildconf/default.ini

@@ -3,7 +3,7 @@ xml = true
 ini = true
 yaml = true
 json = auto
-sqlite3 = auto
+sqlite3 = false
 zeromq = auto
 snmp = true
 sctp = false

buildconf/unbit.ini

@@ -3,7 +3,7 @@ xml = true
 ini = true
 yaml = true
 json = true
-sqlite3 = true
+sqlite3 = false
 zeromq = false
 snmp = false
 sctp = false

cluster.c

@@ -0,0 +1,355 @@
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+#ifdef UWSGI_UDP
+void cluster_setup() {
+
+	int rlen;
+// get cluster configuration
+        if (uwsgi.cluster != NULL) {
+                // get multicast socket
+
+                uwsgi.cluster_fd = uwsgi_cluster_join(uwsgi.cluster);
+
+                uwsgi_log("JOINED CLUSTER: %s\n", uwsgi.cluster);
+
+                // ask for cluster options only if bot pre-existent options are set
+                if (uwsgi.exported_opts_cnt == 1 && !uwsgi.cluster_nodes) {
+                        // now wait max 60 seconds and resend multicast request every 10 seconds
+                        for (;;) {
+                                uwsgi_log("asking \"%s\" uWSGI cluster for configuration data:\n", uwsgi.cluster);
+                                if (uwsgi_send_empty_pkt(uwsgi.cluster_fd, uwsgi.cluster, 99, 0) < 0) {
+                                        uwsgi_log("unable to send multicast message to %s\n", uwsgi.cluster);
+                                        continue;
+                                }
+                              waitfd:
+                                rlen = uwsgi_waitfd(uwsgi.cluster_fd, 10);
+                                if (rlen < 0) {
+                                        break;
+                                }
+                                else if (rlen > 0) {
+                                        // receive the packet
+                                        char clusterbuf[4096];
+                                        if (!uwsgi_hooked_parse_dict_dgram(uwsgi.cluster_fd, clusterbuf, 4096, 99, 1, manage_string_opt, NULL)) {
+                                                uwsgi_configure();
+                                                goto options_parsed;
+                                        }
+                                        else {
+                                                goto waitfd;
+                                        }
+                                }
+                        }
+                }
+              options_parsed:
+
+                if (!uwsgi.cluster_nodes)
+                        uwsgi_cluster_add_me();
+        }
+}
+
+
+
+
+void uwsgi_cluster_add_node(struct uwsgi_cluster_node *nucn, int type) {
+
+        int i;
+        struct uwsgi_cluster_node *ucn;
+        char *tcp_port;
+
+#ifdef UWSGI_DEBUG
+        uwsgi_log("adding node\n");
+#endif
+
+        tcp_port = strchr(nucn->name, ':');
+#ifndef UWSGI_ZEROMQ
+        if (tcp_port == NULL) {
+#else
+        char *zmq_dash = strchr(nucn->name, '-');
+        if (tcp_port == NULL && zmq_dash == NULL) {
+#endif
+
+                fprintf(stdout, "invalid cluster node name %s\n", nucn->name);
+                return;
+        }
+
+        // first check for already present node
+        for (i = 0; i < MAX_CLUSTER_NODES; i++) {
+                ucn = &uwsgi.shared->nodes[i];
+                if (ucn->name[0] != 0) {
+                        if (!strcmp(ucn->name, nucn->name)) {
+                                ucn->status = UWSGI_NODE_OK;
+                                ucn->last_seen = time(NULL);
+                                // update requests
+                                ucn->requests = nucn->requests;
+                                return;
+                        }
+                }
+        }
+
+        for (i = 0; i < MAX_CLUSTER_NODES; i++) {
+                ucn = &uwsgi.shared->nodes[i];
+
+                if (ucn->name[0] == 0) {
+                        memcpy(ucn->name, nucn->name, strlen(nucn->name) + 1);
+                        memcpy(ucn->nodename, nucn->nodename, strlen(nucn->nodename) + 1);
+                        ucn->workers = nucn->workers;
+                        ucn->ucn_addr.sin_family = AF_INET;
+                        if (tcp_port) {
+                                ucn->ucn_addr.sin_port = htons(atoi(tcp_port + 1));
+                                tcp_port[0] = 0;
+                        }
+                        if (nucn->name[0] == 0) {
+                                ucn->ucn_addr.sin_addr.s_addr = INADDR_ANY;
+                        }
+                        else {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("%s\n", nucn->name);
+#endif
+                                ucn->ucn_addr.sin_addr.s_addr = inet_addr(nucn->name);
+                        }
+
+                        ucn->type = type;
+                        // here memory can be freed, as it is allocated by uwsgi_concat2n
+                        if (type != CLUSTER_NODE_DYNAMIC && tcp_port) {
+                                tcp_port[0] = ':';
+                        }
+                        ucn->last_seen = time(NULL);
+                        ucn->requests = nucn->requests;
+                        uwsgi_log("[uWSGI cluster] added node %s\n", ucn->name);
+                        return;
+                }
+        }
+
+        uwsgi_log("unable to add node %s\n", nucn->name);
+}
+
+
+
+int uwsgi_cluster_add_me() {
+
+        const char *key1 = "hostname";
+        const char *key2 = "address";
+        const char *key3 = "workers";
+        const char *key4 = "requests";
+
+        char *ptrbuf;
+        uint16_t ustrlen;
+        char numproc[6];
+
+#ifdef UWSGI_ZEROMQ
+        char uuid_zmq_str[37];
+        uuid_t uuid_zmq;
+        if (!uwsgi.sockets && !uwsgi.zeromq) {
+#else
+        if (!uwsgi.sockets) {
+#endif
+                uwsgi_log("you need to specify at least a socket to start a uWSGI cluster\n");
+                exit(1);
+        }
+
+        snprintf(numproc, 6, "%d", uwsgi.numproc);
+
+        size_t len;
+
+        if (uwsgi.sockets) {
+                len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key2) + 2 + strlen(uwsgi.sockets->name) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
+        }
+#ifdef UWSGI_ZEROMQ
+        else if (uwsgi.zeromq) {
+                uuid_generate(uuid_zmq);
+                uuid_unparse(uuid_zmq, uuid_zmq_str);
+                len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key2) + 2 + strlen(uuid_zmq_str) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
+        }
+#endif
+        else {
+                len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
+        }
+        char *buf = uwsgi_malloc(len);
+
+        ptrbuf = buf;
+
+        ustrlen = strlen(key1);
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, key1, strlen(key1));
+        ptrbuf += strlen(key1);
+
+        ustrlen = strlen(uwsgi.hostname);
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, uwsgi.hostname, strlen(uwsgi.hostname));
+        ptrbuf += strlen(uwsgi.hostname);
+
+
+        if (uwsgi.sockets && uwsgi.sockets->name) {
+                ustrlen = strlen(key2);
+                *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+                *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+                memcpy(ptrbuf, key2, strlen(key2));
+                ptrbuf += strlen(key2);
+
+                ustrlen = strlen(uwsgi.sockets->name);
+                *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+                *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+                memcpy(ptrbuf, uwsgi.sockets->name, strlen(uwsgi.sockets->name));
+                ptrbuf += strlen(uwsgi.sockets->name);
+        }
+#ifdef UWSGI_ZEROMQ
+        else if (uwsgi.zeromq) {
+                ustrlen = strlen(key2);
+                *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+                *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+                memcpy(ptrbuf, key2, strlen(key2));
+                ptrbuf += strlen(key2);
+
+                ustrlen = strlen(uuid_zmq_str);
+                *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+                *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+                memcpy(ptrbuf, uuid_zmq_str, strlen(uuid_zmq_str));
+                ptrbuf += strlen(uuid_zmq_str);
+        }
+#endif
+
+
+	ustrlen = strlen(key3);
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, key3, strlen(key3));
+        ptrbuf += strlen(key3);
+
+        ustrlen = strlen(numproc);
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, numproc, strlen(numproc));
+        ptrbuf += strlen(numproc);
+
+        ustrlen = strlen(key4);
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, key4, strlen(key4));
+        ptrbuf += strlen(key4);
+
+        ustrlen = 1;
+        *ptrbuf++ = (uint8_t) (ustrlen & 0xff);
+        *ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
+        memcpy(ptrbuf, "0", 1);
+        ptrbuf += 1;
+
+
+        uwsgi_string_sendto(uwsgi.cluster_fd, 95, 0, (struct sockaddr *) &uwsgi.mc_cluster_addr, sizeof(uwsgi.mc_cluster_addr), buf, len);
+
+        free(buf);
+
+#ifdef UWSGI_DEBUG
+        uwsgi_log("add_me() successfull\n");
+#endif
+
+        return 0;
+}
+
+
+int uwsgi_cluster_join(char *name) {
+
+        int fd;
+        char *cp;
+        int broadcast = 0;
+
+
+
+        if (name[0] == ':') {
+                fd = bind_to_udp(name, 0, 1);
+                broadcast = 1;
+        }
+        else {
+                fd = bind_to_udp(name, 1, 0);
+        }
+
+        if (fd >= 0) {
+                cp = strchr(name, ':');
+                cp[0] = 0;
+                uwsgi.mc_cluster_addr.sin_family = AF_INET;
+                if (broadcast) {
+                        uwsgi.mc_cluster_addr.sin_addr.s_addr = INADDR_BROADCAST;
+                }
+                else {
+                        uwsgi.mc_cluster_addr.sin_addr.s_addr = inet_addr(name);
+                }
+                uwsgi.mc_cluster_addr.sin_port = htons(atoi(cp + 1));
+                cp[0] = ':';
+
+
+                // announce my presence to all the nodes
+                uwsgi_string_sendto(fd, 73, 0, (struct sockaddr *) &uwsgi.mc_cluster_addr, sizeof(uwsgi.mc_cluster_addr), uwsgi.hostname, strlen(uwsgi.hostname));
+        }
+        else {
+                exit(1);
+        }
+
+
+        return fd;
+
+}
+
+
+char *uwsgi_cluster_best_node() {
+
+        int i;
+        int best_node = -1;
+        struct uwsgi_cluster_node *ucn;
+
+        for (i = 0; i < MAX_CLUSTER_NODES; i++) {
+                ucn = &uwsgi.shared->nodes[i];
+                if (ucn->name[0] != 0 && ucn->status == UWSGI_NODE_OK) {
+                        if (best_node == -1) {
+                                best_node = i;
+                        }
+                        else {
+                                if (ucn->last_choosen < uwsgi.shared->nodes[best_node].last_choosen) {
+                                        best_node = i;
+                                }
+                        }
+                }
+        }
+
+        if (best_node == -1) {
+                return NULL;
+        }
+
+        uwsgi.shared->nodes[best_node].last_choosen = time(NULL);
+        return uwsgi.shared->nodes[best_node].name;
+}
+
+
+void manage_cluster_announce(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
+
+        char *tmpstr;
+        struct uwsgi_cluster_node *ucn = (struct uwsgi_cluster_node *) data;
+
+#ifdef UWSGI_DEBUG
+        uwsgi_log("%.*s = %.*s\n", keylen, key, vallen, val);
+#endif
+
+        if (!uwsgi_strncmp("hostname", 8, key, keylen)) {
+                strncpy(ucn->nodename, val, UMIN(vallen, 255));
+        }
+
+        if (!uwsgi_strncmp("address", 7, key, keylen)) {
+                strncpy(ucn->name, val, UMIN(vallen, 100));
+        }
+
+        if (!uwsgi_strncmp("workers", 7, key, keylen)) {
+                tmpstr = uwsgi_concat2n(val, vallen, "", 0);
+                ucn->workers = atoi(tmpstr);
+                free(tmpstr);
+        }
+
+        if (!uwsgi_strncmp("requests", 8, key, keylen)) {
+                tmpstr = uwsgi_concat2n(val, vallen, "", 0);
+                ucn->requests = strtoul(tmpstr, NULL, 0);
+                free(tmpstr);
+        }
+}
+
+#endif
+

event.c

@@ -567,6 +567,16 @@ struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
 #endif
 
 #ifdef UWSGI_EVENT_FILEMONITOR_USE_INOTIFY
+
+
+#ifdef OBSOLETE_LINUX_KERNEL
+int event_queue_add_file_monitor(int eq, char *filename, int *id) {
+	return -1;
+}
+struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
+	return NULL;
+}
+#else
 #include <sys/inotify.h>
 
 int event_queue_add_file_monitor(int eq, char *filename, int *id) {
@@ -659,6 +669,8 @@ struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
 	return NULL;
 	
 }
+
+#endif
 #endif
 
 #ifdef UWSGI_EVENT_TIMER_USE_TIMERFD

lib/netlink.c

@@ -1,5 +1,20 @@
 #include "../uwsgi.h"
 
+#ifdef OBSOLETE_LINUX_KERNEL
+#ifndef __u16
+#define __u16           u_int16_t
+#endif
+#ifndef __u32
+#define __u32           u_int32_t
+#endif
+#ifndef __s32
+#define __s32           int32_t
+#endif
+#ifndef __u8
+#define __u8           u_int8_t
+#endif
+#endif
+
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 #include <net/if.h>

lock.c

@@ -4,7 +4,12 @@
 #ifdef UWSGI_LOCK_USE_MUTEX
 
 #define UWSGI_LOCK_SIZE	sizeof(pthread_mutexattr_t) + sizeof(pthread_mutex_t)
+
+#ifdef OBSOLETE_LINUX_KERNEL
+#define UWSGI_RWLOCK_SIZE	sizeof(pthread_mutexattr_t) + sizeof(pthread_mutex_t)
+#else
 #define UWSGI_RWLOCK_SIZE	sizeof(pthread_rwlockattr_t) + sizeof(pthread_rwlock_t)
+#endif
 
 // REMEMBER lock must contains space for both pthread_mutex_t and pthread_mutexattr_t !!! 
 void uwsgi_lock_init(void *lock) {
@@ -27,15 +32,27 @@ void uwsgi_lock_init(void *lock) {
 }
 
 void uwsgi_rlock(void *lock) {
+#ifdef OBSOLETE_LINUX_KERNEL
+	uwsgi_lock(lock);
+#else
 	pthread_rwlock_rdlock((pthread_rwlock_t *) lock + sizeof(pthread_rwlockattr_t));
+#endif
 }
 
 void uwsgi_wlock(void *lock) {
+#ifdef OBSOLETE_LINUX_KERNEL
+	uwsgi_lock(lock);
+#else
 	pthread_rwlock_wrlock((pthread_rwlock_t *) lock + sizeof(pthread_rwlockattr_t));
+#endif
 }
 
 void uwsgi_rwunlock(void *lock) {
+#ifdef OBSOLETE_LINUX_KERNEL
+	uwsgi_unlock(lock);
+#else
 	pthread_rwlock_unlock((pthread_rwlock_t *) lock + sizeof(pthread_rwlockattr_t));
+#endif
 }
 
 void uwsgi_lock(void *lock) {
@@ -51,6 +68,9 @@ void uwsgi_unlock(void *lock) {
 
 void uwsgi_rwlock_init(void *lock) {
 
+#ifdef OBSOLETE_LINUX_KERNEL
+	uwsgi_lock_init(lock);
+#else
         if (pthread_rwlockattr_init((pthread_rwlockattr_t *) lock)) {
                 uwsgi_log("unable to allocate rwlock structure\n");
                 exit(1);
@@ -64,6 +84,7 @@ void uwsgi_rwlock_init(void *lock) {
                 uwsgi_log("unable to initialize rwlock\n");
                 exit(1);
         }
+#endif
 
 
 }

master.c

@@ -67,56 +67,7 @@ void expire_rb_timeouts(struct rb_root *root) {
         }
 }
 
-void uwsgi_send_subscription(char *udp_address, char *key, size_t keysize, char *modifier1, size_t modifier1_len) {
-	char *ssb;
-	char subscrbuf[4096];
-
-	uint16_t ustrlen;
-
-	ssb = subscrbuf;
-
-        ustrlen = 3;
-        *ssb++ = (uint8_t) (ustrlen  & 0xff);
-        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        memcpy(ssb, "key", ustrlen);
-        ssb+=ustrlen;
-
-        ustrlen = keysize;
-        *ssb++ = (uint8_t) (ustrlen  & 0xff);
-        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        memcpy(ssb, key, ustrlen);
-        ssb+=ustrlen;
-
-        ustrlen = 7;
-        *ssb++ = (uint8_t) (ustrlen  & 0xff);
-        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        memcpy(ssb, "address", ustrlen);
-        ssb+=ustrlen;
-
-        ustrlen = strlen(uwsgi.sockets->name);
-        *ssb++ = (uint8_t) (ustrlen  & 0xff);
-        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        memcpy(ssb, uwsgi.sockets->name, ustrlen);
-        ssb+=ustrlen;
-
-	if (modifier1) {
-		ustrlen = 9;
-        	*ssb++ = (uint8_t) (ustrlen  & 0xff);
-        	*ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        	memcpy(ssb, "modifier1", ustrlen);
-        	ssb+=ustrlen;
-
-        	ustrlen = modifier1_len;
-        	*ssb++ = (uint8_t) (ustrlen  & 0xff);
-        	*ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        	memcpy(ssb, modifier1, ustrlen);
-        	ssb+=ustrlen;
-	}
-
-        send_udp_message(224, udp_address, subscrbuf, ssb-subscrbuf);
-}
-
-void uwsgi_subscribe(char *subscription) {
+void uwsgi_subscribe(char *subscription, uint8_t cmd) {
 
 	int subfile_size;
 	int i;
@@ -149,7 +100,7 @@ void uwsgi_subscribe(char *subscription) {
                         					modifier1_len = strlen(modifier1);
 								keysize = strlen(key);
                 					}
-							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len);
+							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len, cmd);
 							modifier1 = NULL;
 							modifier1_len = 0;
 						}
@@ -167,7 +118,7 @@ void uwsgi_subscribe(char *subscription) {
                         					modifier1_len = strlen(modifier1);
 								keysize = strlen(key);
                 					}
-							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len);
+							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len, cmd);
 							modifier1 = NULL;
 							modifier1_len = 0;
 							lines[i] = '\n';
@@ -191,7 +142,7 @@ void uwsgi_subscribe(char *subscription) {
 			modifier1_len = strlen(modifier1);
 		}
 
-		uwsgi_send_subscription(udp_address, subscription_key+1, strlen(subscription_key+1), modifier1, modifier1_len);
+		uwsgi_send_subscription(udp_address, subscription_key+1, strlen(subscription_key+1), modifier1, modifier1_len, cmd);
 		if (modifier1)
 			modifier1[-1] = ',';
 	}
@@ -233,35 +184,6 @@ void get_linux_tcp_info(int fd) {
 }
 #endif
 
-void manage_cluster_announce(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
-
-	char *tmpstr;
-	struct uwsgi_cluster_node *ucn = (struct uwsgi_cluster_node *) data;
-
-#ifdef UWSGI_DEBUG
-	uwsgi_log("%.*s = %.*s\n", keylen, key, vallen, val);
-#endif
-
-	if (!uwsgi_strncmp("hostname", 8, key, keylen)) {
-		strncpy(ucn->nodename, val, UMIN(vallen, 255));
-	}
-
-	if (!uwsgi_strncmp("address", 7, key, keylen)) {
-		strncpy(ucn->name, val, UMIN(vallen, 100));
-	}
-
-	if (!uwsgi_strncmp("workers", 7, key, keylen)) {
-		tmpstr = uwsgi_concat2n(val, vallen, "", 0);
-		ucn->workers = atoi(tmpstr);
-		free(tmpstr);
-	}
-
-	if (!uwsgi_strncmp("requests", 8, key, keylen)) {
-		tmpstr = uwsgi_concat2n(val, vallen, "", 0);
-		ucn->requests = strtoul(tmpstr, NULL, 0);
-		free(tmpstr);
-	}
-}
 
 int master_loop(char **argv, char **environ) {
 
@@ -532,10 +454,21 @@ int master_loop(char **argv, char **environ) {
                 }
         }
 
+	// spawn daemons
+	struct uwsgi_daemon *ud = uwsgi.daemons;
+	while(ud) {
+        	if (!ud->registered) {
+                        spawn_daemon(ud);
+                        ud->registered = 1;
+                }
+		ud = ud->next;
+        }
+
+
 	// first subscription
 	struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
 	while(subscriptions) {
-		uwsgi_subscribe(subscriptions->value);
+		uwsgi_subscribe(subscriptions->value, 0);
 		subscriptions = subscriptions->next;
 	}
 
@@ -712,7 +645,7 @@ healthy:
 
 		if ((uwsgi.cheap || ready_to_die >= uwsgi.numproc) && uwsgi.to_hell) {
 			// call a series of waitpid to ensure all processes (gateways, mules and daemons) are dead
-			for(i=0;i<(uwsgi.gateways_cnt+ushared->daemons_cnt+uwsgi.mules_cnt);i++) {
+			for(i=0;i<(uwsgi.gateways_cnt+uwsgi.daemons_cnt+uwsgi.mules_cnt);i++) {
 				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			}
 
@@ -721,7 +654,7 @@ healthy:
 		}
 		if ( (uwsgi.cheap || ready_to_reload >= uwsgi.numproc) && uwsgi.to_heaven) {
 			// call a series of waitpid to ensure all processes (gateways, mules and daemons) are dead
-			for(i=0;i<(uwsgi.gateways_cnt+ushared->daemons_cnt+uwsgi.mules_cnt);i++) {
+			for(i=0;i<(uwsgi.gateways_cnt+uwsgi.daemons_cnt+uwsgi.mules_cnt);i++) {
 				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			}
 
@@ -789,7 +722,7 @@ healthy:
 
 		if (!uwsgi.cheap) {
 
-			if (uwsgi.numproc > 0 || uwsgi.gateways_cnt > 0 || ushared->daemons_cnt > 0) {
+			if (uwsgi.numproc > 0 || uwsgi.gateways_cnt > 0 || uwsgi.daemons_cnt > 0) {
 				master_has_children = 1;
 			}
 #ifdef UWSGI_SPOOLER
@@ -840,16 +773,6 @@ healthy:
 				}
 			}
 
-			// add unregistered daemons
-			// locking is not needed as daemons can only increase (for now)
-			for(i=0;i<ushared->daemons_cnt;i++) {
-				if (!ushared->daemons[i].registered) {
-					uwsgi_log("spawning daemon %s\n", ushared->daemons[i].command);
-					spawn_daemon(&ushared->daemons[i]);
-					ushared->daemons[i].registered = 1;		
-				}
-			}
-
 
 			// add unregistered timers
 			// locking is not needed as timers can only increase
@@ -902,6 +825,22 @@ healthy:
 					uwsgi_manage_command_cron(time(NULL));
 				}
 
+					
+				// check for probes
+				if (ushared->probes_cnt > 0) {
+					uwsgi_lock(uwsgi.probe_table_lock);
+					for(i=0;i<ushared->probes_cnt;i++) {
+						if (interesting_fd == -1) {
+							// increment cycles
+							ushared->probes[i].cycles++;
+						}
+						if (ushared->probes[i].func(interesting_fd, &ushared->probes[i])) { 
+                                               		uwsgi_route_signal(ushared->probes[i].sig);
+                                        	}
+					}
+					uwsgi_unlock(uwsgi.probe_table_lock);
+				}
+
 				if (rlen > 0) {
 
 					if (uwsgi.log_master) {
@@ -1163,6 +1102,7 @@ healthy:
 
 					next_iteration = 0;
 
+					uwsgi_lock(uwsgi.timer_table_lock);
 					for(i=0;i<ushared->timers_cnt;i++) {
                                                 if (ushared->timers[i].registered) {
                                                         if (interesting_fd == ushared->timers[i].fd) {
@@ -1173,6 +1113,7 @@ healthy:
                                                         }
                                                 }
                                         }
+					uwsgi_unlock(uwsgi.timer_table_lock);
                                         if (next_iteration) continue;
 
 
@@ -1449,11 +1390,11 @@ healthy:
 				uwsgi_cluster_add_me();
 			}
 
-			// resubscribe every 10 cycles
-			if (uwsgi.subscriptions && ((uwsgi.master_cycles % 10) == 0 || uwsgi.master_cycles == 1)) {
+			// resubscribe every 10 cycles by default
+			if (uwsgi.subscriptions && ((uwsgi.master_cycles % uwsgi.subscribe_freq) == 0 || uwsgi.master_cycles == 1)) {
 				struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
 				while(subscriptions) {
-					uwsgi_subscribe(subscriptions->value);
+					uwsgi_subscribe(subscriptions->value, 0);
 					subscriptions = subscriptions->next;
 				}
 			}
@@ -1541,12 +1482,14 @@ healthy:
 		/* reload the daemons */
                 // TODO reload_gateway(diedpid);
                 pid_found = 0;
-                for(i=0;i<uwsgi.shared->daemons_cnt;i++) {
-                        if (uwsgi.shared->daemons[i].pid == diedpid) {
-                                spawn_daemon(&uwsgi.shared->daemons[i]);
+		struct uwsgi_daemon *ud = uwsgi.daemons;
+		while(ud) {
+                        if (ud->pid == diedpid) {
+                        	spawn_daemon(ud);
                                 pid_found = 1;
                                 break;
                         }
+			ud = ud->next;
                 }
 
 		if (pid_found) continue;
@@ -1589,11 +1532,13 @@ healthy:
 				}
 			}
 
-			for(i=0;i<uwsgi.shared->daemons_cnt;i++) {
-				if (uwsgi.shared->daemons[i].pid == diedpid) {
-					uwsgi_log("daemon %d (pid: %d) annihilated\n", i+1, (int) diedpid);
+			struct uwsgi_daemon *ud = uwsgi.daemons;
+			while(ud) {
+				if (ud->pid == diedpid) {
+					uwsgi_log("daemon \"%s\" (pid: %d) annihilated\n", ud->command, (int) diedpid);
 					goto next;
 				}
+				ud = ud->next;
 			}
 
 			if (WIFEXITED(waitpid_status)) {

master_utils.c

@@ -104,6 +104,8 @@ int uwsgi_respawn_worker(int wid) {
 		uwsgi.workers[uwsgi.mywid].harakiri = 0;
 		// do not reset worker counters on reload !!!
 		//uwsgi.workers[uwsgi.mywid].requests = 0;
+		// ...but maintain a delta counter (yes this is racy in multithread)
+		uwsgi.workers[uwsgi.mywid].delta_requests = 0;	
 		//uwsgi.workers[uwsgi.mywid].failed_requests = 0;
 		uwsgi.workers[uwsgi.mywid].respawn_count++;
 		uwsgi.workers[uwsgi.mywid].last_spawn = uwsgi.current_time;
@@ -179,32 +181,26 @@ void uwsgi_manage_signal_cron(time_t now) {
 				uc_hour = uwsgi_cron_delta->tm_hour;
 			if (ucron->month == -1)
 				uc_month = uwsgi_cron_delta->tm_mon;
+			if (ucron->day == -1)
+				uc_day = uwsgi_cron_delta->tm_mday;
+			if (ucron->week == -1)
+				uc_week = uwsgi_cron_delta->tm_wday;
 
+			int run_task = 0;
 			// mday and wday are ORed
-			if (ucron->day == -1 && ucron->week == -1) {
-				if (ucron->day == -1)
-					uc_day = uwsgi_cron_delta->tm_mday;
-				if (ucron->week == -1)
-					uc_week = uwsgi_cron_delta->tm_wday;
-			}
-			else if (ucron->day == -1) {
-				ucron->day = uwsgi_cron_delta->tm_mday;
-			}
-			else if (ucron->week == -1) {
-				ucron->week = uwsgi_cron_delta->tm_wday;
+			if (ucron->day != -1 && ucron->week != -1) {
+				if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && (uwsgi_cron_delta->tm_mday == uc_day || uwsgi_cron_delta->tm_wday == uc_week)) {
+					run_task = 1;
+				}
 			}
 			else {
-				if (ucron->day == uwsgi_cron_delta->tm_mday) {
-					ucron->week = uwsgi_cron_delta->tm_wday;
-				}
-				else if (ucron->week == uwsgi_cron_delta->tm_wday) {
-					ucron->day = uwsgi_cron_delta->tm_mday;
+				if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
+					run_task = 1;
 				}
 			}
 
-			if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
-
 
+			if (run_task == 1) {
 				// date match, signal it ?
 				if (uwsgi.current_time - ucron->last_job > 60) {
 					uwsgi_route_signal(ucron->sig);
@@ -252,31 +248,26 @@ void uwsgi_manage_command_cron(time_t now) {
 			uc_hour = uwsgi_cron_delta->tm_hour;
 		if (current_cron->month == -1)
 			uc_month = uwsgi_cron_delta->tm_mon;
+		if (current_cron->day == -1)
+			uc_day = uwsgi_cron_delta->tm_mday;
+		if (current_cron->week == -1)
+			uc_week = uwsgi_cron_delta->tm_wday;
 
-		// mday and wday are ORed
-		if (current_cron->day == -1 && current_cron->week == -1) {
-			if (current_cron->day == -1)
-				uc_day = uwsgi_cron_delta->tm_mday;
-			if (current_cron->week == -1)
-				uc_week = uwsgi_cron_delta->tm_wday;
-		}
-		else if (current_cron->day == -1) {
-			current_cron->day = uwsgi_cron_delta->tm_mday;
-		}
-		else if (current_cron->week == -1) {
-			current_cron->week = uwsgi_cron_delta->tm_wday;
-		}
-		else {
-			if (current_cron->day == uwsgi_cron_delta->tm_mday) {
-				current_cron->week = uwsgi_cron_delta->tm_wday;
-			}
-			else if (current_cron->week == uwsgi_cron_delta->tm_wday) {
-				current_cron->day = uwsgi_cron_delta->tm_mday;
-			}
-		}
+		int run_task = 0;
+                        // mday and wday are ORed
+                        if (current_cron->day != -1 && current_cron->week != -1) {
+                                if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && (uwsgi_cron_delta->tm_mday == uc_day || uwsgi_cron_delta->tm_wday == uc_week)) {
+                                        run_task = 1;
+                                }
+                        }
+                        else {
+                                if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
+                                        run_task = 1;
+                                }
+                        }
 
-		if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
 
+                if (run_task == 1) {
 
 			// date match, run command ?
 			if (uwsgi.current_time - current_cron->last_job > 60) {
@@ -341,6 +332,7 @@ void uwsgi_send_stats(int fd) {
 		fprintf(output,"\"id\": %d, ", uwsgi.workers[i+1].id);
 		fprintf(output,"\"pid\": %d, ", (int) uwsgi.workers[i+1].pid);
 		stats_send_llu("\"requests\": %llu, ", uwsgi.workers[i+1].requests);
+		stats_send_llu("\"delta_requests\": %llu, ", uwsgi.workers[i+1].delta_requests);
 		stats_send_llu("\"exceptions\": %llu, ", uwsgi.workers[i+1].exceptions);
 		stats_send_llu("\"signals\": %llu, ", uwsgi.workers[i+1].signals);
 

plugins/cgi/cgi_plugin.c

@@ -6,7 +6,7 @@ extern struct uwsgi_server uwsgi;
 
 char *cgi_docroot;
 
-#define LONG_ARGS_CGI_BASE	17000 + ((9 + 1) * 100)
+#define LONG_ARGS_CGI_BASE	17000 + ((9 + 1) * 1000)
 #define LONG_ARGS_CGI		LONG_ARGS_CGI_BASE + 1
 
 struct option uwsgi_cgi_options[] = {
@@ -32,6 +32,8 @@ int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 	int waitpid_status;
 	char *argv[2];
 	char full_path[PATH_MAX];
+	int cgi_pipe[2];
+	ssize_t len;
 
 	/* Standard CGI request */
 	if (!wsgi_req->uh.pktsize) {
@@ -47,6 +49,26 @@ int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 
 	// check for file availability (and 'runnability')
 
+	char *path_info = uwsgi_concat4n(cgi_docroot, strlen(cgi_docroot), "/", 1,wsgi_req->path_info, wsgi_req->path_info_len, "", 0);
+	uwsgi_log("requested %s %s\n", path_info, realpath(path_info, full_path));
+
+	if (access(full_path, R_OK)) {
+		wsgi_req->status = 404;
+		wsgi_req->socket->proto_write(wsgi_req, "HTTP/1.1 404 Not Found\r\n\r\n", 26);
+		return UWSGI_OK;
+	}
+
+	if (access(full_path, X_OK)) {
+		wsgi_req->status = 500;
+		wsgi_req->socket->proto_write(wsgi_req, "HTTP/1.1 500 Internal Server Error\r\n\r\n", 26);
+		return UWSGI_OK;
+	}
+
+	if (pipe(cgi_pipe)) {
+		uwsgi_error("pipe()");
+		return UWSGI_OK;
+	}
+
 	cgi_pid = fork();
 
 	if (cgi_pid < 0) {
@@ -59,6 +81,29 @@ int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 		close(wsgi_req->poll.fd);
 		wsgi_req->fd_closed = 1;
 
+		// wait for data
+		char startbuf[8];
+		char *ptr = startbuf;
+		int remains = 8;
+		while(remains > 0) {
+			uwsgi_log("waiting for fd\n");
+			int ret = uwsgi_waitfd(cgi_pipe[0], 10);
+			uwsgi_log("data available\n");
+			if (ret > 0) {
+				len = read(cgi_pipe[0], ptr, remains);
+				if (len > 0) {
+					ptr+=len;
+					remains -= len;
+				}
+			}
+		}
+
+		uwsgi_log("STARTBUF %.*s\n", 8, startbuf);
+
+		if (!memcmp(startbuf, "Status: ", 8)) {
+			wsgi_req->socket->proto_write(wsgi_req, "HTTP/1.1 "
+		}
+
 		// now wait for fd	
 		if (waitpid(cgi_pid, &waitpid_status ,0) > 0) {
 			uwsgi_log("CGI FINISHED\n");
@@ -69,18 +114,19 @@ int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 	// close all the fd except wsgi_req->poll.fd and 2;
 
 	for(i=0;i< (int)uwsgi.max_fd;i++) {
-		if (i != wsgi_req->poll.fd && i != 2) {
+		if (i != wsgi_req->poll.fd && i != 2 && i != cgi_pipe[0] && i != cgi_pipe[1]) {
 			close(i);
 		}
 	}
 
-	// now map wsgi_req->poll.fd to 0 && 1
+	// now map wsgi_req->poll.fd to 0 & cgi_pipe[1] to 1
 	if (wsgi_req->poll.fd != 0) {
 		dup2(wsgi_req->poll.fd, 0);
 		close(wsgi_req->poll.fd);
 	}
 
-	dup2(0,1);
+	uwsgi_log("mapping cgi_pipe %d to 1\n", cgi_pipe[1]);
+	dup2(cgi_pipe[1],1);
 	
 
 	// fill cgi env
@@ -92,8 +138,6 @@ int uwsgi_cgi_request(struct wsgi_request *wsgi_req) {
 		i++;
 	}
 
-	char *path_info = uwsgi_concat4n(cgi_docroot, strlen(cgi_docroot), "/", 1,wsgi_req->path_info, wsgi_req->path_info_len, "", 0);
-	uwsgi_log("requested %s %s\n", path_info, realpath(path_info, full_path));
 
 	argv[0] = full_path;
 	argv[1] = NULL;

plugins/fastrouter/fastrouter.c

@@ -20,6 +20,7 @@
 #define LONG_ARGS_FASTROUTER_TIMEOUT			150006
 #define LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT		150007
 #define LONG_ARGS_FASTROUTER_USE_CODE_STRING		150008
+#define LONG_ARGS_FASTROUTER_TOLERANCE			150009
 
 #define FASTROUTER_STATUS_FREE 0
 #define FASTROUTER_STATUS_CONNECTING 1
@@ -71,8 +72,21 @@ struct uwsgi_fastrouter {
 
 	int cheap;
 	int i_am_cheap;
+
+	int tolerance;
 } ufr;
 
+static void fastrouter_go_cheap(void) {
+
+	uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
+        struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+        while(ufr_sock) {
+        	event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());
+                ufr_sock = ufr_sock->next;
+        }
+        ufr.i_am_cheap = 1;
+}
+
 
 static struct uwsgi_fastrouter_socket *uwsgi_fastrouter_new_socket(char *name) {
 
@@ -165,41 +179,28 @@ struct fastrouter_session {
 
 static void close_session(struct fastrouter_session **fr_table, struct fastrouter_session *fr_session) {
 
-	// check timeout expired
-	if (fr_session == NULL) {
-		if (ufr.subscription_server) {
-			//time_t current_time = time(NULL);
-			uwsgi_log("checking for node health\n");
-			struct uwsgi_subscribe_slot *slot = ufr.subscriptions;
-			while(slot) {
-				struct uwsgi_subscribe_node *node = slot->nodes;
-				while(node) {
-					uwsgi_log("%.*s (hits: %llu) %.*s\n", slot->keylen, slot->key, slot->hits, node->len, node->name);
-					node = node->next;
-				}
-				slot = slot->next;
-			}
-			del_check_timeout(ufr.subscriptions_check);
-			ufr.subscriptions_check = add_check_timeout(10);
-		}
-		return;
-	}
-
 	close(fr_session->fd);
 	fr_table[fr_session->fd] = NULL;
 	if (fr_session->instance_fd != -1) {
-		if (ufr.subscriptions && (fr_session->instance_failed || fr_session->status == FASTROUTER_STATUS_CONNECTING)) {
-			if (fr_session->un && fr_session->un->len > 0) {
-				uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
-                        	uwsgi_remove_subscribe_node(&ufr.subscriptions, fr_session->un);
+		if (ufr.subscriptions && fr_session->un && fr_session->un->len > 0) {
+			// decrease reference count
+#ifdef UWSGI_DEBUG
+			uwsgi_log("[1] node %.*s refcnt: %llu\n", fr_session->un->len, fr_session->un->name, fr_session->un->reference);
+#endif
+			fr_session->un->reference--;
+#ifdef UWSGI_DEBUG
+			uwsgi_log("[2] node %.*s refcnt: %llu\n", fr_session->un->len, fr_session->un->name, fr_session->un->reference);
+#endif
+			if (fr_session->instance_failed || fr_session->status == FASTROUTER_STATUS_CONNECTING) {
+				if (fr_session->un->death_mark == 0)
+					uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
+				fr_session->un->death_mark = 1;
+				// check if i can remove the node
+				if (fr_session->un->reference == 0) {
+                        		uwsgi_remove_subscribe_node(&ufr.subscriptions, fr_session->un);
+				}
                                 if (ufr.subscriptions == NULL && ufr.cheap && !ufr.i_am_cheap) {
-                                	uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
-                                        struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
-                                        while(ufr_sock) {
-                                        	event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());
-                                                ufr_sock = ufr_sock->next;
-                                        }
-					ufr.i_am_cheap = 1;
+					fastrouter_go_cheap();
                                 }
 
 			}
@@ -437,15 +438,34 @@ void fastrouter_loop() {
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
-					if (uwsgi_add_subscribe_node(&ufr.subscriptions, &usr, ufr.subscription_regexp) && ufr.i_am_cheap) {
-						struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
-                                                while(ufr_sock) {
-                                                	event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
-                                                        ufr_sock = ufr_sock->next;
-                                                }
-						ufr.i_am_cheap = 0;
-						uwsgi_log("[uwsgi-fastrouter] leaving cheap mode...\n");	
+					// subscribe request ?
+					if (bbuf[3] == 0) {
+						if (uwsgi_add_subscribe_node(&ufr.subscriptions, &usr, ufr.subscription_regexp) && ufr.i_am_cheap) {
+							struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+                                                	while(ufr_sock) {
+                                                		event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
+                                                        	ufr_sock = ufr_sock->next;
+                                                	}
+							ufr.i_am_cheap = 0;
+							uwsgi_log("[uwsgi-fastrouter] leaving cheap mode...\n");	
+						}
 					}
+					//unsubscribe 
+					else {
+						struct uwsgi_subscribe_node *node = uwsgi_get_subscribe_node_by_name(&ufr.subscriptions, usr.key, usr.keylen, usr.address, usr.address_len, ufr.subscription_regexp);	
+						if (node && node->len) {
+							if (node->death_mark == 0)
+								uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) usr.keylen, usr.key, (int) usr.address_len, usr.address);
+							node->death_mark = 1;
+                                			// check if i can remove the node
+                                			if (node->reference == 0) {
+                                        			uwsgi_remove_subscribe_node(&ufr.subscriptions, node);
+                                			}
+                                			if (ufr.subscriptions == NULL && ufr.cheap && !ufr.i_am_cheap) {
+								fastrouter_go_cheap();
+                                			}
+						}
+					}	
 				}
 			}
 			else {
@@ -524,6 +544,9 @@ void fastrouter_loop() {
 									fr_session->instance_address_len = fr_session->un->len;
 									fr_session->modifier1 = fr_session->un->modifier1;
 								}
+								else if (ufr.subscriptions == NULL && ufr.cheap && !ufr.i_am_cheap) {
+									fastrouter_go_cheap();
+                                				}
 							}
 							else if (ufr.base) {
 								tmp_socket_name = uwsgi_concat2nn(ufr.base, ufr.base_len, fr_session->hostname, fr_session->hostname_len, &tmp_socket_name_len);
@@ -558,23 +581,6 @@ void fastrouter_loop() {
 							if (tmp_socket_name) free(tmp_socket_name);
 
 							if (fr_session->instance_fd < 0) {
-								/*
-								if (ufr.subscription_server) {
-									if (fr_session->un && fr_session->un->len > 0) { 
-	                                                        		uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
-                                						uwsgi_remove_subscribe_node(&ufr.subscriptions, fr_session->un);	 
-										if (ufr.subscriptions == NULL && ufr.cheap && !ufr.i_am_cheap) {
-											uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
-											struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;	
-											while(ufr_sock) {
-												event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());	
-												ufr_sock = ufr_sock->next;
-											}
-											ufr.i_am_cheap = 1;
-										}
-                        						}
-	                                                        }
-								*/
 								fr_session->instance_failed = 1;
 								close_session(fr_table, fr_session);
                                                         	break;

plugins/nagios/nagios.c

@@ -15,49 +15,48 @@ struct option nagios_options[] = {
 
 int nagios() {
 
-	char *tcp_port;
-	struct wsgi_request nagios_req;
-// connect and send
+	struct uwsgi_header uh;
+	char *buf = NULL;
 
 	if (!use_nagios) {
 		return 1;
 	}
+
 	if (!uwsgi.sockets) {
 		fprintf(stdout, "UWSGI UNKNOWN: you have specified an invalid socket\n");
 		exit(3);
 	}
-	tcp_port = strchr(uwsgi.sockets->name, ':');
-	if (tcp_port == NULL) {
-		fprintf(stdout, "UWSGI UNKNOWN: you have specified an invalid socket\n");
-		exit(3);
-	}
 
-	tcp_port[0] = 0;
 
-	int fd = connect_to_tcp(uwsgi.sockets->name, atoi(tcp_port + 1), uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], 0);
+	int fd = uwsgi_connect(uwsgi.sockets->name, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], 0);
 	if (fd < 0) {
 		fprintf(stdout, "UWSGI CRITICAL: could not connect() to workers\n");
 		exit(2);
 	}
-	nagios_req.uh.modifier1 = UWSGI_MODIFIER_PING;
-	nagios_req.uh.pktsize = 0;
-	nagios_req.uh.modifier2 = 0;
-	if (write(fd, &nagios_req.uh, 4) != 4) {
+
+	uh.modifier1 = UWSGI_MODIFIER_PING;
+	uh.pktsize = 0;
+	uh.modifier2 = 0;
+	if (write(fd, &uh, 4) != 4) {
 		uwsgi_error("write()");
 		fprintf(stdout, "UWSGI CRITICAL: could not send ping packet to workers\n");
 		exit(2);
 	}
 
-	nagios_req.poll.fd = fd;
-	nagios_req.poll.events = POLLIN;
 
-	if (!uwsgi_parse_packet(&nagios_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT])) {
+	int ret = uwsgi_read_response(fd, &uh, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], &buf);
+
+	if (ret == -2) {
 		fprintf(stdout, "UWSGI CRITICAL: timed out waiting for response\n");
 		exit(2);
 	}
+	else if (ret == -1) {
+		fprintf(stdout, "UWSGI CRITICAL: error reading response\n");
+		exit(2);
+	}
 	else {
-		if (nagios_req.uh.pktsize > 0) {
-			fprintf(stdout, "UWSGI WARNING: %.*s\n", nagios_req.uh.pktsize, nagios_req.buffer);
+		if (uh.pktsize > 0 && buf) {
+			fprintf(stdout, "UWSGI WARNING: %.*s\n", uh.pktsize, buf);
 			exit(1);
 		}
 		else {

plugins/ping/ping_plugin.c

@@ -15,8 +15,8 @@ struct option uwsgi_ping_options[] = {
 
 static void ping() {
 
-	struct wsgi_request ping_req;
-	char *buf = uwsgi_malloc(uwsgi.buffer_size);
+	struct uwsgi_header uh;
+	char *buf = NULL;
 
 	// use a 3 secs timeout by default
 	if (!uping.ping_timeout) uping.ping_timeout = 3;
@@ -28,25 +28,22 @@ static void ping() {
 		exit(1);
 	}
 
-	memset(&ping_req, 0, sizeof(struct wsgi_request));
-	ping_req.uh.modifier1 = UWSGI_MODIFIER_PING;
-	ping_req.uh.pktsize = 0;
-	ping_req.uh.modifier2 = 0;
-	if (write(fd, &ping_req.uh, 4) != 4) {
+	uh.modifier1 = UWSGI_MODIFIER_PING;
+	uh.pktsize = 0;
+	uh.modifier2 = 0;
+
+	if (write(fd, &uh, 4) != 4) {
 		uwsgi_error("write()");
 		exit(2);
 	}
-	ping_req.poll.fd = fd;
-	ping_req.poll.events = POLLIN;
 
-	ping_req.buffer = buf;
-
-	if (!uwsgi_parse_packet(&ping_req, uping.ping_timeout)) {
+	int ret = uwsgi_read_response(fd, &uh, uping.ping_timeout, &buf);
+	if (ret < 0) {
 		exit(1);
 	}
 	else {
-		if (ping_req.uh.pktsize > 0) {
-			uwsgi_log("[WARNING] node %s message: %.*s\n", uping.ping, ping_req.uh.pktsize, buf);
+		if (uh.pktsize > 0) {
+			uwsgi_log("[WARNING] node %s message: %.*s\n", uping.ping, uh.pktsize, buf);
 			exit(2);
 		}
 		else {
@@ -98,6 +95,7 @@ int uwsgi_ping_manage_options(int i, char *optarg) {
 
 	switch(i) {
 		case LONG_ARGS_PING:
+			uwsgi.no_initial_output = 1;
 			uwsgi.no_server = 1;
 			uping.ping = optarg;
 			return 1;

plugins/probeconnect/connectprobe.c

@@ -0,0 +1,90 @@
+#include "../../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+int connect_prober_callback(int interesting_fd, struct uwsgi_signal_probe *up) {
+
+	// is this a timeout event ?
+	if (interesting_fd == -1) {
+		// am i wating for something ?
+		if (up->fd != -1) {
+			if (up->cycles > (uint64_t) up->timeout) {
+				// reset the cycle
+				up->cycles = 0;
+				close(up->fd);
+				up->fd = -1;
+				// state = NOOP
+				up->state = 0;
+				// avoid duplicated events
+				if (!up->bad) {
+					up->bad = 1;
+					return 1;
+				}
+			}
+		}
+		// ok register a new event
+		else {
+			if ((up->cycles % up->freq) == 0) {
+				up->fd = uwsgi_connect(up->args, -1, 1);
+				if (up->fd != -1) {
+					// status = CONNECTING
+					up->state = 1;
+					event_queue_add_fd_write(uwsgi.master_queue, up->fd);
+					return 0;
+				}
+				// signal the bad event (if not already bad)
+				if (!up->bad) {
+					up->bad = 1;
+					return 1;
+				}
+
+			}
+		}
+	}
+	else if (up->fd != -1) {
+		// is this event for me ?
+		if (interesting_fd == up->fd) {
+			// uselsess here (we have only one state), only to show a good practice
+			// check the state
+			if (up->state == 1) {
+				if (uwsgi_is_bad_connection(up->fd)) {
+					// signal the bad connection (if needed)
+					up->cycles = 0;
+					close(up->fd);
+					up->fd = -1;
+					// state = NOOP
+					up->state = 0;
+					if (!up->bad) {
+						up->bad = 1;
+						return 1;
+					}
+					return 0;
+				}
+				// this is a good connection
+				up->cycles = 0;
+				close(up->fd);
+				up->fd = -1;
+				// state = NOOP
+				up->state = 0;
+				if (up->bad) {
+					up->bad = 0;
+					return 1;
+				}
+			}
+		}
+	}
+
+	// default action
+	return 0;
+}
+
+int probeconnect_init() {
+
+	uwsgi_probe_register(&uwsgi.probes, "connect", connect_prober_callback);
+	return 0;
+}
+
+struct uwsgi_plugin probeconnect_plugin = {
+
+	.init = probeconnect_init,
+};

plugins/probeconnect/uwsgiplugin.py

@@ -0,0 +1,7 @@
+
+NAME='probeconnect'
+CFLAGS = []
+LDFLAGS = []
+LIBS = []
+
+GCC_LIST = ['connectprobe']

plugins/probepg/pgprobe.c

@@ -0,0 +1,132 @@
+#include "../../uwsgi.h"
+#include <libpq-fe.h>
+
+extern struct uwsgi_server uwsgi;
+int pg_prober_callback(int, struct uwsgi_signal_probe *);
+int probepg_init(void);
+
+int pg_prober_callback(int interesting_fd, struct uwsgi_signal_probe *up) {
+
+	// is this a timeout event ?
+	if (interesting_fd == -1) {
+		// am i wating for something ?
+		if (up->fd != -1) {
+			if (up->cycles > (uint64_t) up->timeout) {
+				// reset the cycle
+				up->cycles = 0;
+				PQfinish((PGconn *) up->data);
+				up->fd = -1;
+				// state = NOOP
+				up->state = 0;
+				// avoid duplicated events
+				if (!up->bad) {
+					up->bad = 1;
+					return 1;
+				}
+			}
+		}
+		// ok register a new event
+		else {
+			if ((up->cycles % up->freq) == 0) {
+				up->last_event = event_queue_write();
+				up->data = (void *) PQconnectStart(up->args);
+				if (up->data) {
+					// status = CONNECTING
+					up->state = PQstatus((PGconn *) up->data);
+					if (up->state == CONNECTION_BAD)
+						goto bad;
+					up->fd = PQsocket((PGconn *) up->data);
+					event_queue_add_fd_write(uwsgi.master_queue, up->fd);
+					return 0;
+				}
+			      bad:
+				// signal the bad event (if not already bad)
+				if (!up->bad) {
+					up->bad = 1;
+					return 1;
+				}
+
+			}
+		}
+	}
+	else if (up->fd != -1) {
+		// is this event for me ?
+		if (interesting_fd == up->fd) {
+			// check the state
+			up->state = PQstatus((PGconn *) up->data);
+			if (up->state == CONNECTION_BAD) {
+				// signal the bad connection (if needed)
+				up->cycles = 0;
+				PQfinish((PGconn *) up->data);
+				up->fd = -1;
+				up->state = 0;
+				if (!up->bad) {
+					up->bad = 1;
+					return 1;
+				}
+				return 0;
+			}
+			else if (up->state == CONNECTION_OK) {
+				up->cycles = 0;
+				PQfinish((PGconn *) up->data);
+				up->fd = -1;
+				// state = NOOP
+				up->state = 0;
+				if (up->bad) {
+					up->bad = 0;
+					return 1;
+				}
+			}
+			// still wait...
+			else {
+				PostgresPollingStatusType wait_type = PQconnectPoll((PGconn *) up->data);
+				// the connection is good
+				if (wait_type == PGRES_POLLING_ACTIVE || wait_type == PGRES_POLLING_FAILED || wait_type == PGRES_POLLING_OK) {
+					if (wait_type == PGRES_POLLING_ACTIVE)
+						wait_type = PQconnectPoll((PGconn *) up->data);
+					up->cycles = 0;
+					up->fd = -1;
+					// state = NOOP
+					up->state = 0;
+					PQfinish((PGconn *) up->data);
+					if (wait_type == PGRES_POLLING_FAILED) {
+						if (!up->bad) {
+							up->bad = 1;
+							return 1;
+						}
+					}
+					else {
+						if (up->bad) {
+							up->bad = 0;
+							return 1;
+						}
+					}
+				}
+				else if (wait_type == PGRES_POLLING_READING) {
+					event_queue_del_fd(uwsgi.master_queue, up->fd, up->last_event);
+					event_queue_add_fd_read(uwsgi.master_queue, up->fd);
+					up->last_event = event_queue_read();
+				}
+				else if (wait_type == PGRES_POLLING_WRITING) {
+					event_queue_del_fd(uwsgi.master_queue, up->fd, up->last_event);
+					event_queue_add_fd_write(uwsgi.master_queue, up->fd);
+					up->last_event = event_queue_write();
+				}
+			}
+		}
+	}
+
+	// default action
+	return 0;
+}
+
+int probepg_init() {
+
+	uwsgi_probe_register(&uwsgi.probes, "pg", pg_prober_callback);
+	return 0;
+}
+
+struct uwsgi_plugin probepg_plugin = {
+
+	.init = probepg_init,
+};

plugins/probepg/uwsgiplugin.py

@@ -0,0 +1,9 @@
+import os
+
+NAME='probepg'
+CFLAGS = os.popen('pg_config --cflags').read().rstrip().split()
+CFLAGS.append('-I' + os.popen('pg_config --includedir').read().rstrip())
+LDFLAGS = os.popen('pg_config --ldflags').read().rstrip().split()
+LIBS = ['-L' + os.popen('pg_config --libdir').read().rstrip(), '-lpq']
+
+GCC_LIST = ['pgprobe']

plugins/python/pump_subhandler.c

@@ -342,12 +342,12 @@ int uwsgi_response_subhandler_pump(struct wsgi_request *wsgi_req) {
 				UWSGI_RELEASE_GIL
 				return UWSGI_AGAIN;
 			}
+#endif
 		}
 		else {
 			uwsgi_log("invalid Pump response.\n"); 
 			goto clear; 
 		}
-#endif
 	}
 
 

plugins/python/python_plugin.c

@@ -106,9 +106,9 @@ int uwsgi_python_init() {
 
 #ifndef UWSGI_PYPY
 	char *pyversion = strchr(Py_GetVersion(), '\n');
-        uwsgi_log("Python version: %.*s %s\n", pyversion-Py_GetVersion(), Py_GetVersion(), Py_GetCompiler()+1);
+        uwsgi_log_initial("Python version: %.*s %s\n", pyversion-Py_GetVersion(), Py_GetVersion(), Py_GetCompiler()+1);
 #else
-	uwsgi_log("PyPy version: %s\n", PYPY_VERSION);
+	uwsgi_log_initial("PyPy version: %s\n", PYPY_VERSION);
 #endif
 
 #ifndef UWSGI_PYPY
@@ -160,7 +160,7 @@ int uwsgi_python_init() {
         up.reset_ts = simple_reset_ts;
 	
 
-	uwsgi_log("Python main interpreter initialized at %p\n", up.main_thread);
+	uwsgi_log_initial("Python main interpreter initialized at %p\n", up.main_thread);
 
 	return 1;
 
@@ -253,7 +253,6 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 			if (!pyfile) {
 				uwsgi_error_open(real_filename);
 				free(real_filename);
-				fclose(pyfile);
 				return NULL;
 			}
 		}
@@ -1091,8 +1090,34 @@ void uwsgi_python_init_thread(int core_id) {
 	pthread_setspecific(up.upt_save_key, (void *) pts);
 	pthread_setspecific(up.upt_gil_key, (void *) pts);
 #ifdef UWSGI_DEBUG
-	uwsgi_log("pts %d = %p\n", core_id, pts);
+	uwsgi_log("python ThreadState %d = %p\n", core_id, pts);
 #endif
+	UWSGI_GET_GIL;
+	// call threading.currentThread (taken from mod_wsgi, but removes DECREFs as thread in uWSGI are fixed)
+	PyObject *threading_module = PyImport_ImportModule("threading");
+        if (threading_module) {
+        	PyObject *threading_module_dict = PyModule_GetDict(threading_module);
+                if (threading_module_dict) {
+#ifdef PYTHREE
+			PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "current_thread");
+#else
+			PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "currentThread");
+#endif
+                        if (threading_current) {
+                                PyObject *current_thread = PyEval_CallObject(threading_current, (PyObject *)NULL);
+                                if (!current_thread) {
+					// ignore the error
+                                        PyErr_Clear();
+                                }
+				else {
+					PyObject_SetAttrString(current_thread, "name", PyString_FromFormat("uWSGIWorker%dCore%d", uwsgi.mywid, core_id));
+					Py_INCREF(current_thread);
+				}
+                        }
+                }
+        }
+	UWSGI_RELEASE_GIL;
+	
 
 }
 

plugins/python/uwsgi_pymodule.c

@@ -220,6 +220,25 @@ PyObject *py_uwsgi_add_cron(PyObject * self, PyObject * args) {
 	return Py_True;
 }
 
+
+PyObject *py_uwsgi_add_probe(PyObject * self, PyObject * args) {
+
+        uint8_t uwsgi_signal;
+	int timeout = 0;
+	int freq = 0;
+        char *probe, *probe_args;
+
+        if (!PyArg_ParseTuple(args, "Bss|ii:add_probe", &uwsgi_signal, &probe, &probe_args, &timeout, &freq)) {
+                return NULL;
+        }
+
+        if (uwsgi_add_probe(uwsgi_signal, probe, probe_args, timeout, freq))
+                return PyErr_Format(PyExc_ValueError, "unable to add probe");
+
+        Py_INCREF(Py_None);
+        return Py_None;
+}
+
 	
 
 PyObject *py_uwsgi_add_timer(PyObject * self, PyObject * args) {
@@ -464,23 +483,6 @@ PyObject *py_uwsgi_register_rpc(PyObject * self, PyObject * args) {
 	return Py_True;
 }
 
-PyObject *py_uwsgi_attach_daemon(PyObject * self, PyObject * args) {
-
-	char *command = NULL;
-
-	if (!PyArg_ParseTuple(args, "s:attach_daemon", &command)) {
-		return NULL;
-	}
-
-	if (uwsgi_attach_daemon(command)) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-
-	Py_INCREF(Py_True);
-	return Py_True;
-}
-
 PyObject *py_uwsgi_signal_registered(PyObject * self, PyObject * args) {
 	uint8_t uwsgi_signal;
 
@@ -1942,13 +1944,18 @@ PyObject *py_uwsgi_load_plugin(PyObject * self, PyObject * args) {
 PyObject *py_uwsgi_multicast(PyObject * self, PyObject * args) {
 
 	char *host, *message;
+	Py_ssize_t message_len;
 	ssize_t ret;
+	char *uwsgi_message;
 
-	if (!PyArg_ParseTuple(args, "ss:send_multicast_message", &host, &message)) {
+	if (!PyArg_ParseTuple(args, "ss#:send_multicast_message", &host, &message, &message_len)) {
 		return NULL;
 	}
 
-	ret = send_udp_message(UWSGI_MODIFIER_MULTICAST, host, message, strlen(message));
+	uwsgi_message = uwsgi_malloc(message_len+4);
+	memcpy(uwsgi_message+4, message, message_len);
+	ret = send_udp_message(UWSGI_MODIFIER_MULTICAST, 0, host, uwsgi_message, message_len);
+	free(uwsgi_message);
 
 	if (ret <= 0) {
 		Py_INCREF(Py_None);
@@ -2485,6 +2492,12 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 		}
 		Py_DECREF(zero);
 
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].delta_requests);
+		if (PyDict_SetItemString(worker_dict, "delta_requests", zero)) {
+			goto clear;
+		}
+		Py_DECREF(zero);
+
 		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].signals);
 		if (PyDict_SetItemString(worker_dict, "signals", zero)) {
 			goto clear;
@@ -3010,8 +3023,6 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 
 	{"listen_queue", py_uwsgi_listen_queue, METH_VARARGS, ""},
 
-	{"attach_daemon", py_uwsgi_attach_daemon, METH_VARARGS, ""},
-
 	{"register_signal", py_uwsgi_register_signal, METH_VARARGS, ""},
 	{"signal", py_uwsgi_signal, METH_VARARGS, ""},
 	{"signal_wait", py_uwsgi_signal_wait, METH_VARARGS, ""},
@@ -3019,6 +3030,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"signal_received", py_uwsgi_signal_received, METH_VARARGS, ""},
 	{"add_file_monitor", py_uwsgi_add_file_monitor, METH_VARARGS, ""},
 	{"add_timer", py_uwsgi_add_timer, METH_VARARGS, ""},
+	{"add_probe", py_uwsgi_add_probe, METH_VARARGS, ""},
 	{"add_rb_timer", py_uwsgi_add_rb_timer, METH_VARARGS, ""},
 	{"add_cron", py_uwsgi_add_cron, METH_VARARGS, ""},
 

plugins/python/web3_subhandler.c

@@ -192,12 +192,12 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 				UWSGI_RELEASE_GIL
 				return UWSGI_AGAIN;
 			}
+#endif
 		}
 		else {
 			uwsgi_log("invalid Web3 response.\n"); 
 			goto clear; 
 		}
-#endif
 	}
 
 

plugins/rack/rack_api.c

@@ -6,6 +6,26 @@ extern struct uwsgi_rack ur;
 
 #define uwsgi_rack_api(x, y, z) rb_define_module_function(rb_uwsgi_embedded, x, y, z)
 
+VALUE rack_uwsgi_warning(VALUE *class, VALUE rbmessage) {
+
+	Check_Type(rbmessage, T_STRING);
+        char *message = RSTRING_PTR(rbmessage);
+	size_t len = RSTRING_LEN(rbmessage);
+
+        if (len > 80) {
+                uwsgi_log("- warning message must be max 80 chars, it will be truncated -");
+                memcpy(uwsgi.shared->warning_message, message, 80);
+                uwsgi.shared->warning_message[80] = 0;
+        }
+        else {
+                memcpy(uwsgi.shared->warning_message, message, len);
+                uwsgi.shared->warning_message[len] = 0;
+        }
+
+        return Qnil;
+}
+
+
 VALUE rack_uwsgi_setprocname(VALUE *class, VALUE rbname) {
 
 	Check_Type(rbname, T_STRING);
@@ -690,6 +710,8 @@ void uwsgi_rack_init_api() {
         uwsgi_rack_api("mule_id", rack_uwsgi_mule_id, 0);
         uwsgi_rack_api("logsize", rack_uwsgi_logsize, 0);
 
+        uwsgi_rack_api("set_warning_message", rack_uwsgi_warning, 1);
+
 	
 
 	if (uwsgi.cache_max_items > 0) {

plugins/rack/rack_plugin.c

@@ -211,8 +211,6 @@ int uwsgi_rack_init(){
                 http_sc->message_size = (int) strlen(http_sc->message);
         }
 
-	ur.unprotected = 0;
-
 #ifdef RUBY19
 	ruby_sysinit(&argc, &argv);
 	RUBY_INIT_STACK
@@ -330,7 +328,7 @@ VALUE call_dispatch(VALUE env) {
 
 }
 
-VALUE send_body(VALUE obj) {
+static VALUE send_body(VALUE obj) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 	ssize_t len = 0;
@@ -348,6 +346,15 @@ VALUE send_body(VALUE obj) {
 	return Qnil;
 }
 
+VALUE body_to_path(VALUE body) {
+        return rb_funcall( body, rb_intern("to_path"), 0);
+}
+
+
+VALUE close_body(VALUE body) {
+	return rb_funcall( body, rb_intern("close"), 0);
+}
+
 VALUE iterate_body(VALUE body) {
 
 #ifdef RUBY19
@@ -355,7 +362,6 @@ VALUE iterate_body(VALUE body) {
 #else
 	return rb_iterate(rb_each, body, send_body, 0);
 #endif
-
 }
 
 VALUE send_header(VALUE obj, VALUE headers) {
@@ -544,13 +550,7 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 	rb_hash_aset(env, rb_str_new2("rack.errors"), rb_funcall( rb_const_get(rb_cObject, rb_intern("IO")), rb_intern("new"), 2, INT2NUM(2), rb_str_new("w",1) ));
 
 
-	if (ur.unprotected) {
-		ret = rb_funcall(ur.dispatcher, ur.call, 1, env);
-	}
-	else {
-		ret = rb_protect( call_dispatch, env, &error);
-	}
-	
+	ret = rb_protect( call_dispatch, env, &error);
 	if (error) {
 		uwsgi_ruby_exception();
 		//return -1;
@@ -600,21 +600,12 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 
 		headers = RARRAY_PTR(ret)[1] ;
 		if (rb_respond_to( headers, rb_intern("each") )) {
-			if (ur.unprotected) {
-#ifdef RUBY19
-        			rb_block_call(headers, rb_intern("each"), 0, 0, send_header, headers);
-#else
-        			rb_iterate(rb_each, headers, send_header, headers);
-#endif
-			}
-			else {
-				rb_protect( iterate_headers, headers, &error);
-				if (error) {
-					uwsgi_ruby_exception();
-					rb_gc_unregister_address(&status);
-                			rb_gc_unregister_address(&headers);
-					goto clear;
-				}
+			rb_protect( iterate_headers, headers, &error);
+			if (error) {
+				uwsgi_ruby_exception();
+				rb_gc_unregister_address(&status);
+                		rb_gc_unregister_address(&headers);
+				goto clear;
 			}
 		}
 
@@ -624,38 +615,38 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 
 		body = RARRAY_PTR(ret)[2] ;
 
-		if (rb_respond_to( body, rb_intern("to_path") )) {
-			VALUE sendfile_path = rb_funcall( body, rb_intern("to_path"), 0);
-			wsgi_req->sendfile_fd = open(RSTRING_PTR(sendfile_path), O_RDONLY);
-			wsgi_req->response_size = uwsgi_sendfile(wsgi_req);
-			if (wsgi_req->response_size > 0) {
-				while(wsgi_req->response_size < wsgi_req->sendfile_fd_size) {
-					//uwsgi_log("sendfile_fd_size = %d\n", wsgi_req->sendfile_fd_size);
-					wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
-				}
-			}
-			rb_gc_unregister_address(&sendfile_path);
+		// TODO protect to_path
 
-		}
-		else if (rb_respond_to( body, rb_intern("each") )) {
-			if (ur.unprotected) {
-#ifdef RUBY19
-        			rb_block_call(body, rb_intern("each"), 0, 0, send_body, 0);
-#else
-        			rb_iterate(rb_each, body, send_body, 0);
-#endif
+		if (rb_respond_to( body, rb_intern("to_path") )) {
+			VALUE sendfile_path = rb_protect( body_to_path, body, &error);
+			if (error) {
+				uwsgi_ruby_exception();
 			}
 			else {
-				rb_protect( iterate_body, body, &error);
-				if (error) {
-					uwsgi_ruby_exception();
+				wsgi_req->sendfile_fd = open(RSTRING_PTR(sendfile_path), O_RDONLY);
+				wsgi_req->response_size = uwsgi_sendfile(wsgi_req);
+				if (wsgi_req->response_size > 0) {
+					while(wsgi_req->response_size < wsgi_req->sendfile_fd_size) {
+						//uwsgi_log("sendfile_fd_size = %d\n", wsgi_req->sendfile_fd_size);
+						wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
+					}
 				}
+				rb_gc_unregister_address(&sendfile_path);
+			}
+		}
+		else if (rb_respond_to( body, rb_intern("each") )) {
+			rb_protect( iterate_body, body, &error);
+			if (error) {
+				uwsgi_ruby_exception();
 			}
 		}
 
 		if (rb_respond_to( body, rb_intern("close") )) {
 			//uwsgi_log("calling close\n");
-			rb_funcall( body, rb_intern("close"), 0);
+			rb_protect( close_body, body, &error);
+			if (error) {
+                                uwsgi_ruby_exception();
+                        }
 		}
 
 //fine:
@@ -732,6 +723,44 @@ void uwsgi_rack_resume(struct wsgi_request *wsgi_req) {
 	uwsgi_log("RESUMING RUBY\n");
 }
 
+#ifdef RUBY19
+VALUE uwsgi_call_block(VALUE body, VALUE block) {
+
+	return rb_funcall(block, rb_intern("call"), 1, body );
+}
+
+VALUE uwsgi_rack_patch_body_proxy_each(int argc, VALUE *argv, VALUE self) {
+
+	VALUE block = Qnil;
+	rb_scan_args(argc, argv, "0&", &block);
+
+	if(!RTEST(block)) {
+		rb_raise(rb_eArgError, "a block is required");
+		return Qnil;
+	}
+
+	VALUE original_body = rb_iv_get(self, "@body");
+	if (original_body != Qnil) {
+		return rb_block_call(original_body, rb_intern("each"), 0, 0, uwsgi_call_block, block);
+	}
+
+	return Qnil;
+}
+
+VALUE uwsgi_rack_patch_body_proxy(VALUE foo) {
+
+	VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
+	VALUE rack_body_proxy = rb_const_get(rack, rb_intern("BodyProxy"));	
+
+	if (!rb_respond_to(rack_body_proxy, rb_intern("each"))) {
+		rb_define_method(rack_body_proxy, "each", uwsgi_rack_patch_body_proxy_each, -1);
+		return Qtrue;
+	}
+
+	return Qnil;
+}
+#endif
+
 VALUE init_rack_app( VALUE script ) {
 
 	int error;
@@ -746,6 +775,14 @@ VALUE init_rack_app( VALUE script ) {
         }
 
         VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
+
+#ifdef RUBY19
+	VALUE ret = rb_protect(uwsgi_rack_patch_body_proxy, rack, &error);
+	if (!error && ret != Qnil) {
+		uwsgi_log("Rack::BodyProxy successfully patched for ruby 1.9.x\n");
+	}
+#endif
+
         VALUE rackup = rb_funcall( rb_const_get(rack, rb_intern("Builder")), rb_intern("parse_file"), 1, script);
         if (TYPE(rackup) != T_ARRAY) {
         	uwsgi_log("unable to parse %s file\n", RSTRING_PTR(script));

plugins/rack/uwsgi_rack.h

@@ -62,7 +62,6 @@ struct uwsgi_rack {
         VALUE rb_uwsgi_io_class;
         ID call;
         VALUE fibers[200];
-        int unprotected;
 
         pthread_mutex_t gvl;
 

plugins/rrdtool/rrdtool.c

@@ -46,7 +46,7 @@ int rrdtool_init() {
 
 	if (!u_rrd.max_ds) u_rrd.max_ds = 30;
 
-	uwsgi_log("*** RRDtool library available at %p ***\n", u_rrd.lib);
+	uwsgi_log_initial("*** RRDtool library available at %p ***\n", u_rrd.lib);
 
 	return 0;
 }

protocol.c

@@ -123,16 +123,21 @@ time_t parse_http_date(char *date, uint16_t len) {
 }
 
 #ifdef UWSGI_UDP
-ssize_t send_udp_message(uint8_t modifier1, char *host, char *message, uint16_t message_size) {
+ssize_t send_udp_message(uint8_t modifier1, uint8_t modifier2, char *host, char *message, uint16_t message_size) {
 
 	int fd;
 	struct sockaddr_in udp_addr;
 	char *udp_port;
 	ssize_t ret;
-	char udpbuff[1024];
 
-	if (message_size + 4 > 1024)
-		return -1;
+	struct uwsgi_header *uh;
+
+	if (message) {
+		uh = (struct uwsgi_header *) message;
+	}
+	else {
+		uh = (struct uwsgi_header *) uwsgi_malloc(4);
+	}
 
 	udp_port = strchr(host, ':');
 	if (udp_port == NULL) {
@@ -152,22 +157,15 @@ ssize_t send_udp_message(uint8_t modifier1, char *host, char *message, uint16_t
 	udp_addr.sin_port = htons(atoi(udp_port+1));
 	udp_addr.sin_addr.s_addr = inet_addr(host);
 
-	udpbuff[0] = modifier1;
+	uh->modifier1 = modifier1;
 #ifdef __BIG_ENDIAN__
-	message_size = uwsgi_swap16(message_size);
+	uh->pktsize = uwsgi_swap16(message_size);
+#else
+	uh->pktsize = message_size;
 #endif
+	uh->modifier2 = modifier2;
 
-	memcpy(udpbuff+1, &message_size, 2);
-
-	udpbuff[3] = 0;
-
-#ifdef __BIG_ENDIAN__
-	message_size = uwsgi_swap16(message_size);
-#endif
-
-	memcpy(udpbuff+4, message, message_size);
-
-	ret = sendto(fd, udpbuff, message_size+4, 0, (struct sockaddr *) &udp_addr, sizeof(udp_addr));
+	ret = sendto(fd, (char *) uh, message_size+4, 0, (struct sockaddr *) &udp_addr, sizeof(udp_addr));
 	if (ret < 0) {
 		uwsgi_error("sendto()");
 	}
@@ -175,6 +173,10 @@ ssize_t send_udp_message(uint8_t modifier1, char *host, char *message, uint16_t
 
 	udp_port[0] = ':';
 
+	if ((char *)uh != message) {
+		free(uh);
+	}
+
 	return ret;
 	
 }
@@ -342,6 +344,58 @@ ssize_t uwsgi_send_message(int fd, uint8_t modifier1, uint8_t modifier2, char *m
 	return ret;
 }
 
+int uwsgi_read_response(int fd, struct uwsgi_header *uh, int timeout, char **buf) {
+
+	char *ptr = (char *) uh;
+	size_t remains = 4;
+	int ret = -1;
+	int rlen;
+	ssize_t len;
+
+	while(remains > 0) {
+                rlen = uwsgi_waitfd(fd, timeout);
+                if (rlen > 0) {
+                        len = read(fd, ptr, remains);
+                        if (len <= 0) break;
+                        remains -= len;
+                        ptr += len;
+                        if (remains == 0) {
+                                ret = uh->modifier2;
+				break;
+                        }
+                        continue;
+                }
+		// timed out ?
+		else if (ret == 0) ret = -2;
+                break;
+        }
+
+	if (buf && uh->pktsize > 0) {
+		*buf = uwsgi_malloc(uh->pktsize);
+		remains = uh->pktsize;
+		ptr = *buf;
+		ret = -1;
+		while(remains > 0) {
+			rlen = uwsgi_waitfd(fd, timeout);
+			if (rlen > 0) {
+				len = read(fd, ptr, remains);
+				if (len <= 0) break;
+				remains -= len;
+				ptr += len;
+				if (remains == 0) {
+					ret = uh->modifier2;
+					break;
+				}
+				continue;
+			}
+			// timed out ?
+			else if (ret == 0) ret = -2;
+			break;
+		}
+	}
+
+	return ret;
+}
 
 int uwsgi_parse_packet(struct wsgi_request *wsgi_req, int timeout) {
 	int rlen;
@@ -500,6 +554,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 	char *ptrbuf, *bufferend;
 
 	uint16_t strsize = 0;
+	struct uwsgi_dyn_dict *udd;
 
 	ptrbuf = buffer;
 	bufferend = ptrbuf + wsgi_req->uh.pktsize;
@@ -807,25 +862,46 @@ next:
 	}
 
 	// check if a file named uwsgi.check_static+env['PATH_INFO'] exists
-	if (uwsgi.check_static && wsgi_req->path_info_len > 1) {
-		if (!uwsgi_file_serve(wsgi_req, uwsgi.check_static, uwsgi.check_static_len, wsgi_req->path_info, wsgi_req->path_info_len, uwsgi.check_static, uwsgi.check_static_len)) {
-			return -1;
+	
+	if (wsgi_req->path_info_len > 1) {
+		udd = uwsgi.check_static;
+		while(udd) {
+			// need to build the path ?
+			if (udd->value == NULL) {
+				udd->value = realpath(udd->key, NULL);
+				if (!udd->value) goto nextcs;				
+				udd->vallen = strlen(udd->value);
+			}
+
+			if (!uwsgi_file_serve(wsgi_req, udd->value, udd->vallen, wsgi_req->path_info, wsgi_req->path_info_len)) {
+				return -1;
+			}
+nextcs:
+			udd = udd->next;
 		}
 	}
 
 	// check static-map
-	struct uwsgi_static_map *usm = uwsgi.static_maps;
-	while(usm) {
+	udd = uwsgi.static_maps;
+	while(udd) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("checking for %.*s <-> %.*s\n", wsgi_req->path_info_len, wsgi_req->path_info, usm->mountpoint_len, usm->mountpoint);
+		uwsgi_log("checking for %.*s <-> %.*s\n", wsgi_req->path_info_len, wsgi_req->path_info, udd->keylen, udd->key);
 #endif
+		if (udd->status == 0) {
+			char *real_docroot = realpath(udd->value, NULL);
+			if (!real_docroot) goto nextsm;
+			udd->value = real_docroot;
+			udd->vallen = strlen(udd->value);
+			udd->status = 1;
+		}
 
-		if (!uwsgi_starts_with(wsgi_req->path_info, wsgi_req->path_info_len, usm->mountpoint, usm->mountpoint_len)) {
-			if (!uwsgi_file_serve(wsgi_req, usm->document_root, usm->document_root_len, wsgi_req->path_info+usm->mountpoint_len, wsgi_req->path_info_len-usm->mountpoint_len, usm->orig_document_root, usm->orig_document_root_len)) {
+		if (!uwsgi_starts_with(wsgi_req->path_info, wsgi_req->path_info_len, udd->key, udd->keylen)) {
+			if (!uwsgi_file_serve(wsgi_req, udd->value, udd->vallen, wsgi_req->path_info+udd->keylen, wsgi_req->path_info_len-udd->keylen)) {
 				return -1;
 			}
 		}
-		usm = usm->next;
+nextsm:
+		udd = udd->next;
 	}
 
 	return 0;
@@ -1383,7 +1459,7 @@ char *uwsgi_get_mime_type(char *name, int namelen, int *size) {
 	return NULL;
 }
 
-int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_t document_root_len, char *path_info, uint16_t path_info_len, char *orig_document_root, uint16_t orig_document_root_len) {
+int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_t document_root_len, char *path_info, uint16_t path_info_len) {
 
         struct stat st;
         char real_filename[PATH_MAX];
@@ -1454,8 +1530,8 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
 			if (uwsgi.file_serve_mode == 1) {
                                 wsgi_req->header_cnt += 2;
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "X-Accel-Redirect: ", 18);
-				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, orig_document_root, orig_document_root_len);
-				if (orig_document_root[orig_document_root_len-1] != '/') {
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, document_root, document_root_len);
+				if (document_root[document_root_len-1] != '/') {
 					wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "/", 1);
 				}
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, path_info, path_info_len);
@@ -1466,8 +1542,8 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
 			else if (uwsgi.file_serve_mode == 2) {
                                 wsgi_req->header_cnt += 2;
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "X-Sendfile: ", 12);
-				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, orig_document_root, orig_document_root_len);
-                                if (orig_document_root[orig_document_root_len-1] != '/') {
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, document_root, document_root_len);
+                                if (document_root[document_root_len-1] != '/') {
                                         wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "/", 1);
                                 }
                                 wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, path_info, path_info_len);	

signal.c

@@ -128,6 +128,87 @@ int uwsgi_add_file_monitor(uint8_t sig, char *filename) {
 
 }
 
+struct uwsgi_probe *uwsgi_probe_register(struct uwsgi_probe **up, char *name, int (*func)(int, struct uwsgi_signal_probe *)) {
+
+        struct uwsgi_probe *uwsgi_up = *up, *old_up;
+
+        if (!uwsgi_up) {
+                *up = uwsgi_malloc(sizeof(struct uwsgi_probe));
+                uwsgi_up = *up;
+        }
+        else {
+                while(uwsgi_up) {
+                        old_up = uwsgi_up;
+                        uwsgi_up = uwsgi_up->next;
+                }
+
+                uwsgi_up = uwsgi_malloc(sizeof(struct uwsgi_probe));
+                old_up->next = uwsgi_up;
+        }
+
+        uwsgi_up->name = name;
+        uwsgi_up->func = func;
+        uwsgi_up->next = NULL;
+
+	uwsgi_log("registered new probe \"%s\" at %p\n", name, uwsgi_up);
+
+        return uwsgi_up;
+}
+
+
+int uwsgi_add_probe(uint8_t sig, char *kind, char *args, int timeout, int freq) {
+
+	uwsgi_lock(uwsgi.probe_table_lock);
+
+        if (ushared->probes_cnt < MAX_PROBES) {
+
+		struct uwsgi_probe *up = uwsgi.probes;
+		while(up) {
+			if (!strcmp(up->name, kind)) {
+				break;
+			}
+			up = up->next;
+		}
+
+		if (!up) {
+			uwsgi_log("unable to find probe \"%s\" !!!\n", kind);
+                	uwsgi_unlock(uwsgi.probe_table_lock);
+                	return -1;
+		}
+
+                // fill the probe table
+                ushared->probes[ushared->probes_cnt].func = up->func;
+		strncpy(ushared->probes[ushared->probes_cnt].args, args, 1024-1);
+                ushared->probes[ushared->probes_cnt].registered = 0;
+                ushared->probes[ushared->probes_cnt].sig = sig;
+		ushared->probes[ushared->probes_cnt].fd = -1;
+		ushared->probes[ushared->probes_cnt].state = 0;
+		ushared->probes[ushared->probes_cnt].last_event = 0;
+		ushared->probes[ushared->probes_cnt].data = NULL;
+		ushared->probes[ushared->probes_cnt].cycles = 0;
+		ushared->probes[ushared->probes_cnt].bad = 0;
+
+		if (!timeout) {
+			timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT];
+		}
+		ushared->probes[ushared->probes_cnt].timeout = timeout;
+		if (!freq) {
+			freq = 1;
+		}
+		ushared->probes[ushared->probes_cnt].freq = freq;
+                ushared->probes_cnt++;
+        }
+        else {
+                uwsgi_log("you can register max %d probes !!!\n", MAX_PROBES);
+                uwsgi_unlock(uwsgi.probe_table_lock);
+                return -1;
+        }
+
+        uwsgi_unlock(uwsgi.probe_table_lock);
+
+	return 0;
+}
+
 int uwsgi_add_timer(uint8_t sig, int secs) {
 
 	uwsgi_lock(uwsgi.timer_table_lock);
@@ -232,8 +313,6 @@ void create_signal_pipe(int *sigpipe) {
 int uwsgi_remote_signal_send(char *addr, uint8_t sig) {
 
 	struct uwsgi_header uh;
-	size_t remains = 4;
-	char *ptr = (char *) &uh;
 
 	uh.modifier1 = 110;
 	uh.pktsize = 0;
@@ -248,26 +327,10 @@ int uwsgi_remote_signal_send(char *addr, uint8_t sig) {
 		return -1;
 	}
 
-	while(remains > 0) {
-		int rlen = uwsgi_waitfd(fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
-        	if (rlen > 0) {
-			ssize_t len = read(fd, ptr, remains);	
-			if (len <= 0) {
-				break;
-			}
-			remains -= len;
-			ptr += len;
-			if (remains == 0) {
-				close(fd);
-				return uh.modifier2;
-			}
-			continue;	
-		}
-		break;
-	}
+	int ret = uwsgi_read_response(fd, &uh, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], NULL);
 
 	close(fd);
-	return -1;
+	return ret;
 
 }
 

socket.c

@@ -412,7 +412,7 @@ char *generate_socket_name(char *socket_name) {
 				if (!strncmp(socket_name, new_addr, strlen(socket_name))) {
 					asterisk[0] = '*';
 					new_socket = uwsgi_concat3(new_addr, ":", tcp_port + 1);
-					uwsgi_log("found %s for %s on interface %s\n", new_socket, socket_name, ifa->ifa_name);
+					uwsgi_log("[uwsgi-autoip] found %s for %s on interface %s\n", new_socket, socket_name, ifa->ifa_name);
 					freeifaddrs(ifap);
 					return new_socket;
 				}
@@ -1014,3 +1014,16 @@ void uwsgi_del_sockets_from_queue(int queue) {
 
 }
 
+int uwsgi_is_bad_connection(int fd) {
+
+	int soopt = 0;
+	socklen_t solen = sizeof(int) ;
+
+	if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *) (&soopt), &solen) < 0) {
+		return -1;
+	}
+
+	// will be 0 if all ok
+	return soopt;
+}
+

subscription.c

@@ -14,8 +14,12 @@
 	This system is not mean to run on shared memory. If you have multiple processes for the same app, you have to create
 	a new subscriptions slot list.
 
+	To avoid removal of already using nodes, a reference count system has been implemented
+
 */
 
+extern struct uwsgi_server uwsgi;
+
 struct uwsgi_subscribe_slot *uwsgi_get_subscribe_slot(struct uwsgi_subscribe_slot **slot, char *key, uint16_t keylen, int regexp) {
 
 	struct uwsgi_subscribe_slot *current_slot = *slot;
@@ -72,23 +76,63 @@ struct uwsgi_subscribe_node *uwsgi_get_subscribe_node(struct uwsgi_subscribe_slo
 	if (current_slot) {
 		// node found, move up in the list increasing hits
 		current_slot->hits++;
+		time_t current = time(NULL);
 		struct uwsgi_subscribe_node *node = current_slot->nodes;
 		while(node) {
+			// is the node alive ?
+			if (current - node->last_check > uwsgi.subscription_tolerance) {
+				if (node->death_mark == 0)
+					uwsgi_log("[uwsgi-subscription] %.*s => marking %.*s as failed (no announce received in %d seconds)\n", (int) keylen, key, (int) node->len, node->name, uwsgi.subscription_tolerance);
+				node->death_mark = 1;
+			}
+			if (node->death_mark && node->reference == 0) {
+				// remove the node and move to next
+				struct uwsgi_subscribe_node *dead_node = node;
+				node = node->next;
+				// if the slot has been removed, return NULL;
+				if (uwsgi_remove_subscribe_node(slot, dead_node) == 1) {
+					return NULL;
+				}
+				continue;
+			}
 			if (rr_pos == current_slot->rr) {
 				current_slot->rr++;
+				node->reference++;
 				return node;
 			}
 			node = node->next;
 			rr_pos++;
 		}
 		current_slot->rr = 0;
+		if (current_slot->nodes) {
+			current_slot->nodes->reference++;
+		}
 		return current_slot->nodes;
 	}
 
 	return NULL;
 }
 
-void uwsgi_remove_subscribe_node(struct uwsgi_subscribe_slot **slot, struct uwsgi_subscribe_node *node) {
+struct uwsgi_subscribe_node *uwsgi_get_subscribe_node_by_name(struct uwsgi_subscribe_slot **slot, char *key, uint16_t keylen, char *val, uint16_t vallen, int regexp) {
+
+	if (keylen > 0xff) return NULL;
+	struct uwsgi_subscribe_slot *current_slot = uwsgi_get_subscribe_slot(slot, key, keylen, regexp);
+	if (current_slot) {
+		struct uwsgi_subscribe_node *node = current_slot->nodes;
+		while(node) {
+			if (!uwsgi_strncmp(val, vallen, node->name, node->len)) {
+				return node;
+			}			
+			node = node->next;
+		}
+	}
+
+	return NULL;
+}
+
+int uwsgi_remove_subscribe_node(struct uwsgi_subscribe_slot **slot, struct uwsgi_subscribe_node *node) {
+
+	int ret = 0;
 
 	struct uwsgi_subscribe_node *a_node;
 	struct uwsgi_subscribe_slot *node_slot = node->slot;
@@ -132,12 +176,15 @@ void uwsgi_remove_subscribe_node(struct uwsgi_subscribe_slot **slot, struct uwsg
 		}
 #endif
 
+		ret = 1;
 		free(node_slot);
 		// am i the only slot ?
 		if (!prev_slot && !next_slot) {
 			*slot = NULL;
 		}
 	}
+
+	return ret;
 }
 
 struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slot **slot, struct uwsgi_subscribe_req *usr, int regexp) {
@@ -151,6 +198,8 @@ struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slo
 		node = current_slot->nodes;
 		while(node) {
                         if (!uwsgi_strncmp(node->name, node->len, usr->address, usr->address_len)) {
+				// remove death mark
+				node->death_mark = 0;
                                 node->last_check = time(NULL);
                                 return node;
                         }
@@ -162,6 +211,8 @@ struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slo
 		node->len = usr->address_len;
 		node->modifier1 = usr->modifier1;
 		node->modifier2 = usr->modifier2;
+		node->reference = 0;
+		node->death_mark = 0;
 		node->last_check = time(NULL);
 		node->slot = current_slot;
                 memcpy(node->name, usr->address, usr->address_len);
@@ -195,6 +246,8 @@ struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slo
 		current_slot->nodes = uwsgi_malloc(sizeof(struct uwsgi_subscribe_node));
 		current_slot->nodes->slot = current_slot;
 		current_slot->nodes->len = usr->address_len;
+		current_slot->nodes->reference = 0;
+		current_slot->nodes->death_mark = 0;
 		current_slot->nodes->modifier1 = usr->modifier1;
 		current_slot->nodes->modifier2 = usr->modifier2;
 		memcpy(current_slot->nodes->name, usr->address, usr->address_len);
@@ -272,3 +325,59 @@ struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slo
 }
 
 
+void uwsgi_send_subscription(char *udp_address, char *key, size_t keysize, char *modifier1, size_t modifier1_len, uint8_t cmd) {
+
+	size_t ssb_size = 4 + (2 + 3) + (2 + keysize) + (2 + 7) + (2 + strlen(uwsgi.sockets->name));
+
+	if (modifier1) {
+		ssb_size += (2 + 9) + (2 + modifier1_len);
+	}
+
+        char *subscrbuf = uwsgi_malloc(ssb_size);
+	// leave space for uwsgi header
+        char *ssb = subscrbuf+4;
+
+	// key = "domain"
+        uint16_t ustrlen = 3;
+        *ssb++ = (uint8_t) (ustrlen  & 0xff);
+        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        memcpy(ssb, "key", ustrlen);
+        ssb+=ustrlen;
+
+        ustrlen = keysize;
+        *ssb++ = (uint8_t) (ustrlen  & 0xff);
+        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        memcpy(ssb, key, ustrlen);
+        ssb+=ustrlen;
+
+	// address = "first uwsgi socket"
+        ustrlen = 7;
+        *ssb++ = (uint8_t) (ustrlen  & 0xff);
+        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        memcpy(ssb, "address", ustrlen);
+        ssb+=ustrlen;
+
+        ustrlen = strlen(uwsgi.sockets->name);
+        *ssb++ = (uint8_t) (ustrlen  & 0xff);
+        *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        memcpy(ssb, uwsgi.sockets->name, ustrlen);
+        ssb+=ustrlen;
+
+	// modifier1 = "modifier1"
+        if (modifier1) {
+                ustrlen = 9;
+                *ssb++ = (uint8_t) (ustrlen  & 0xff);
+                *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+                memcpy(ssb, "modifier1", ustrlen);
+                ssb+=ustrlen;
+
+                ustrlen = modifier1_len;
+                *ssb++ = (uint8_t) (ustrlen  & 0xff);
+                *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+                memcpy(ssb, modifier1, ustrlen);
+                ssb+=ustrlen;
+        }
+
+        send_udp_message(224, cmd, udp_address, subscrbuf, ssb_size-4);
+}
+

utils.c

@@ -247,6 +247,12 @@ void logto(char *logfile) {
 			exit(1);
 		}
 		uwsgi.logfile = logfile;
+
+		if (uwsgi.chmod_logfile_value) {
+			if (chmod(uwsgi.logfile, uwsgi.chmod_logfile_value)) {
+				uwsgi_error("chmod()");
+			}
+		}
 #ifdef UWSGI_UDP
 	}
 #endif
@@ -470,7 +476,7 @@ void uwsgi_as_root() {
 
 	if (!getuid()) {
 		if (!uwsgi.master_as_root && !uwsgi.uidname) {
-			uwsgi_log("uWSGI running as root, you can use --uid/--gid/--chroot options\n");
+			uwsgi_log_initial("uWSGI running as root, you can use --uid/--gid/--chroot options\n");
 		}
 
 #ifdef UWSGI_CAP
@@ -571,7 +577,7 @@ void uwsgi_as_root() {
 		}
 
 		if (!getuid()) {
-			uwsgi_log("*** WARNING: you are running uWSGI as root !!! (use the --uid flag) *** \n");
+			uwsgi_log_initial("*** WARNING: you are running uWSGI as root !!! (use the --uid flag) *** \n");
 		}
 
 #ifdef UWSGI_CAP
@@ -659,6 +665,8 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 	}
 	uwsgi.workers[0].requests++;
 	uwsgi.workers[uwsgi.mywid].requests++;
+	// this is used for MAX_REQUESTS
+	uwsgi.workers[uwsgi.mywid].delta_requests++;
 
 	// after_request hook
 	if (uwsgi.p[wsgi_req->uh.modifier1]->after_request)
@@ -694,7 +702,7 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 	memset(wsgi_req, 0, sizeof(struct wsgi_request));
 	wsgi_req->async_id = tmp_id;
 
-	if (uwsgi.shared->options[UWSGI_OPTION_MAX_REQUESTS] > 0 && uwsgi.workers[uwsgi.mywid].requests >= uwsgi.shared->options[UWSGI_OPTION_MAX_REQUESTS]) {
+	if (uwsgi.shared->options[UWSGI_OPTION_MAX_REQUESTS] > 0 && uwsgi.workers[uwsgi.mywid].delta_requests >= uwsgi.shared->options[UWSGI_OPTION_MAX_REQUESTS]) {
 		goodbye_cruel_world();
 	}
 
@@ -794,7 +802,8 @@ void uwsgi_linux_ksm_map(void) {
                 		}
 			}
 
-			free(ksm_mappings_last);
+			if (ksm_mappings_last)
+				free(ksm_mappings_last);
 			ksm_mappings_last = ksm_mappings_current;
 			ksm_mappings_last_lines = ksm_mappings_current_lines;
 
@@ -802,6 +811,10 @@ void uwsgi_linux_ksm_map(void) {
 				uwsgi_error("[uwsgi-KSM] unable to share pages");
 			}
 		}
+		// if not dirty, free ksm_mappings_current
+		else {
+			free(ksm_mappings_current);
+		}
 	}
 }
 #endif
@@ -1695,7 +1708,7 @@ int uwsgi_read_whole_body(struct wsgi_request *wsgi_req, char *buf, size_t len)
 	return 0;
 }
 
-void _add_exported_option(char *key, char *value, int configured) {
+void add_exported_option(char *key, char *value, int configured) {
 
 	if (!uwsgi.exported_opts) {
                         uwsgi.exported_opts = uwsgi_malloc(sizeof(struct uwsgi_opt *));
@@ -1715,32 +1728,6 @@ void _add_exported_option(char *key, char *value, int configured) {
                 uwsgi.exported_opts_cnt++;
 }
 
-void add_exported_option(char *key, char *value, int configured) {
-
-	char *v = value;
-	if (value && strchr(value, ';')) {
-		v = uwsgi_str(value);
-		if (v[0] == '\\') {
-			_add_exported_option(key, v+1, configured);
-			return;
-		}
-	}
-
-	if (v == NULL) {
-		_add_exported_option(key, v, configured);
-		return;
-	}
-
-	char *p = strtok(v, ";");
-	while(p != NULL) {
-
-		_add_exported_option(key, p, configured);
-
-		p = strtok(NULL, ";");
-	}
-
-}
-
 int uwsgi_waitfd(int fd, int timeout) {
 
 	int ret;
@@ -1855,6 +1842,44 @@ char *uwsgi_read_fd(int fd, int *size, int add_zero) {
 
 }
 
+char *uwsgi_simple_file_read(char *filename) {
+
+	struct stat sb;
+	char *buffer;
+	ssize_t len;
+	int fd = open(filename, O_RDONLY);
+        if (fd < 0) {
+        	uwsgi_error_open(filename);
+		goto end;		
+        }
+
+        if (fstat(fd, &sb)) {
+        	uwsgi_error("fstat()");
+		close(fd);
+		goto end;
+        }
+
+        buffer = uwsgi_malloc(sb.st_size+1);
+
+        len = read(fd, buffer, sb.st_size);
+        if (len != sb.st_size) {
+        	uwsgi_error("read()");
+		free(buffer);
+		close(fd);
+		goto end;
+        }
+
+        close(fd);
+	if (buffer[sb.st_size-1] == '\n' || buffer[sb.st_size-1] == '\r') {
+		buffer[sb.st_size-1] = 0;
+	}
+	buffer[sb.st_size] = 0;
+	return buffer;
+end:
+	return (char *) "";
+
+}
+
 char *uwsgi_open_and_read(char *url, int *size, int add_zero, char *magic_table[]) {
 
 	int fd;
@@ -2216,32 +2241,6 @@ char *uwsgi_get_last_char(char *what, char c) {
 	return ptr;
 }
 
-int uwsgi_attach_daemon(char *command) {
-
-	struct uwsgi_daemon *d;
-	int ret = -1;
-
-	uwsgi_lock(uwsgi.daemon_table_lock);
-
-	if (uwsgi.shared->daemons_cnt < MAX_DAEMONS) {
-		d = &uwsgi.shared->daemons[uwsgi.shared->daemons_cnt];
-
-		memcpy(d->command, command, UMIN(strlen(command), 0xff - 1));
-		d->registered = 0;
-		d->status = 0;
-
-		uwsgi.shared->daemons_cnt++;
-
-		ret = 0;
-		uwsgi_log("registered daemon %s\n", command);
-	}
-
-	uwsgi_unlock(uwsgi.daemon_table_lock);
-
-	return ret;
-
-}
-
 void spawn_daemon(struct uwsgi_daemon *ud) {
 
 	char *argv[64];
@@ -2298,7 +2297,11 @@ void spawn_daemon(struct uwsgi_daemon *ud) {
 			uwsgi_error("prctl()");
 		}
 #endif
-		memcpy(ud->tmp_command, ud->command, 0xff);
+
+		// free the old area
+		if (ud->tmp_command) free(ud->tmp_command);
+
+		ud->tmp_command = uwsgi_str(ud->command);
 
 		a = strtok(ud->tmp_command, " ");
 		if (a) {
@@ -2318,14 +2321,15 @@ void spawn_daemon(struct uwsgi_daemon *ud) {
 		argv[cnt] = NULL;
 
 		if (throttle) {
-			uwsgi_log_verbose("throttling %s for %d seconds\n", argv[0], throttle);
+			uwsgi_log("[uwsgi-daemons] throttling \"%s\" (%s) for %d seconds\n", ud->command, argv[0], throttle);
 			sleep(throttle);
 		}
 
-		uwsgi_log_verbose("running %s\n", argv[0]);
+		uwsgi_log("[uwsgi-daemons] spawning \"%s\" (%s)\n", ud->command, argv[0]);
 		if (execvp(argv[0], argv)) {
 			uwsgi_error("execvp()");
 		}
+		uwsgi_log("[uwsgi-daemons] unable to spawn \"%s\" (%s)\n", ud->command, argv[0]);
 
 		// never here;
 		exit(1);
@@ -2638,6 +2642,39 @@ char *uwsgi_netstring(char *buf, size_t len, char **netstring, size_t *netstring
 	return NULL;
 }
 
+struct uwsgi_daemon *uwsgi_daemon_new(struct uwsgi_daemon **ud, char *command) {
+
+        struct uwsgi_daemon *uwsgi_ud = *ud, *old_ud;
+
+        if (!uwsgi_ud) {
+                *ud = uwsgi_malloc(sizeof(struct uwsgi_daemon));
+                uwsgi_ud = *ud;
+        }
+        else {
+                while(uwsgi_ud) {
+                        old_ud = uwsgi_ud;
+                        uwsgi_ud = uwsgi_ud->next;
+                }
+
+                uwsgi_ud = uwsgi_malloc(sizeof(struct uwsgi_daemon));
+                old_ud->next = uwsgi_ud;
+        }
+
+        uwsgi_ud->command = command;
+        uwsgi_ud->tmp_command = NULL;
+        uwsgi_ud->pid = 0;
+        uwsgi_ud->status = 0;
+        uwsgi_ud->registered = 0;
+        uwsgi_ud->next = NULL;
+	uwsgi_ud->respawns = 0;
+	uwsgi_ud->last_spawn = 0;
+
+	uwsgi.daemons_cnt++;
+
+        return uwsgi_ud;
+}
+
+
 struct uwsgi_dyn_dict *uwsgi_dyn_dict_new(struct uwsgi_dyn_dict **dd, char *key, int keylen, char *val, int vallen) {
 
         struct uwsgi_dyn_dict *uwsgi_dd = *dd, *old_dd;
@@ -2663,6 +2700,7 @@ struct uwsgi_dyn_dict *uwsgi_dyn_dict_new(struct uwsgi_dyn_dict **dd, char *key,
         uwsgi_dd->value = val;
         uwsgi_dd->vallen = vallen;
 	uwsgi_dd->hits = 0;
+	uwsgi_dd->status = 0;
         uwsgi_dd->next = NULL;
 
         return uwsgi_dd;
@@ -3145,12 +3183,24 @@ static struct uwsgi_cap uwsgi_cap_list[] = {
 	{ "sys_time", CAP_SYS_TIME},
 	{ "sys_tty_config", CAP_SYS_TTY_CONFIG},
 	{ "mknod", CAP_MKNOD},
+#ifdef CAP_LEASE
 	{ "lease", CAP_LEASE},
+#endif
+#ifdef CAP_AUDIT_WRITE
 	{ "audit_write", CAP_AUDIT_WRITE},
+#endif
+#ifdef CAP_AUDIT_CONTROL
 	{ "audit_control", CAP_AUDIT_CONTROL},
+#endif
+#ifdef CAP_SETFCAP
 	{ "setfcap", CAP_SETFCAP},
+#endif
+#ifdef CAP_MAC_OVERRIDE
 	{ "mac_override", CAP_MAC_OVERRIDE},
+#endif
+#ifdef CAP_MAC_ADMIN
 	{ "mac_admin", CAP_MAC_ADMIN},
+#endif
 #ifdef CAP_SYSLOG
 	{ "syslog", CAP_SYSLOG},
 #endif

uwsgi.c

@@ -93,6 +93,7 @@ static struct option long_base_options[] = {
 	{"emperor", required_argument, 0, LONG_ARGS_EMPEROR},
 	{"emperor-tyrant", no_argument, &uwsgi.emperor_tyrant, 1},
 	{"emperor-stats", required_argument, 0, LONG_ARGS_EMPEROR_STATS},
+	{"emperor-stats-server", required_argument, 0, LONG_ARGS_EMPEROR_STATS},
 	{"early-emperor", no_argument, &uwsgi.early_emperor, 1},
 	{"emperor-broodlord", required_argument, 0, LONG_ARGS_EMPEROR_BROODLORD},
 	{"emperor-amqp-vhost", required_argument, 0, LONG_ARGS_EMPEROR_AMQP_VHOST},
@@ -196,6 +197,7 @@ static struct option long_base_options[] = {
 	{"udp", required_argument, 0, LONG_ARGS_UDP},
 #endif
 	{"stats", required_argument, 0, LONG_ARGS_STATS},
+	{"stats-server", required_argument, 0, LONG_ARGS_STATS},
 #ifdef UWSGI_MULTICAST
 	{"multicast", required_argument, 0, LONG_ARGS_MULTICAST},
 	{"cluster", required_argument, 0, LONG_ARGS_CLUSTER},
@@ -204,6 +206,10 @@ static struct option long_base_options[] = {
 	{"cluster-log", required_argument, 0, LONG_ARGS_CLUSTER_LOG},
 #endif
 	{"subscribe-to", required_argument, 0, LONG_ARGS_SUBSCRIBE_TO},
+	{"st", required_argument, 0, LONG_ARGS_SUBSCRIBE_TO},
+	{"subscribe", required_argument, 0, LONG_ARGS_SUBSCRIBE_TO},
+	{"subscribe-freq", required_argument, 0, LONG_ARGS_SUBSCRIBE_FREQ},
+	{"subscription-tolerance", required_argument, 0, LONG_ARGS_SUBSCR_TOLERANCE},
 #ifdef UWSGI_SNMP
 	{"snmp", optional_argument, 0, LONG_ARGS_SNMP},
 	{"snmp-community", required_argument, 0, LONG_ARGS_SNMP_COMMUNITY},
@@ -217,6 +223,7 @@ static struct option long_base_options[] = {
 	{"logto", required_argument, 0, LONG_ARGS_LOGTO},
 	{"logto2", required_argument, 0, LONG_ARGS_LOGTO2},
 	{"logfile-chown", no_argument, &uwsgi.logfile_chown, 1},
+	{"logfile-chmod", required_argument, 0, LONG_ARGS_LOGFILE_CHMOD},
 	{"log-syslog", optional_argument, 0, LONG_ARGS_LOG_SYSLOG},
 	{"log-socket", required_argument, 0, LONG_ARGS_LOG_SOCKET},
 #ifdef UWSGI_ZEROMQ
@@ -522,6 +529,15 @@ void kill_them_all(int signum) {
 	}
 
 	uwsgi_log("SIGINT/SIGQUIT received...killing workers...\n");
+
+	// unsubscribe if needed
+	struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
+        while(subscriptions) {
+                uwsgi_subscribe(subscriptions->value, 1);
+                subscriptions = subscriptions->next;
+        }
+
+
 	for (i = 1; i <= uwsgi.numproc; i++) {
 		if (uwsgi.workers[i].pid > 0)
 			kill(uwsgi.workers[i].pid, SIGINT);
@@ -542,9 +558,11 @@ void kill_them_all(int signum) {
 	}
 
 
-	for (i = 0; i < uwsgi.shared->daemons_cnt; i++) {
-		if (uwsgi.shared->daemons[i].pid > 0)
-			kill(-uwsgi.shared->daemons[i].pid, SIGKILL);
+	struct uwsgi_daemon *ud = uwsgi.daemons;
+	while(ud) {
+		if (ud->pid > 0)
+			kill(-ud->pid, SIGKILL);
+		ud = ud->next;
 	}
 
 	for (i = 0; i < uwsgi.gateways_cnt; i++) {
@@ -590,10 +608,12 @@ void grace_them_all(int signum) {
 		uwsgi_log("killing the emperor with pid %d\n", uwsgi.emperor_pid);
 	}
 
-	for (i = 0; i < uwsgi.shared->daemons_cnt; i++) {
-		if (uwsgi.shared->daemons[i].pid > 0)
-			kill(-uwsgi.shared->daemons[i].pid, SIGKILL);
-	}
+	struct uwsgi_daemon *ud = uwsgi.daemons;
+        while(ud) {
+                if (ud->pid > 0)
+                        kill(-ud->pid, SIGKILL);
+                ud = ud->next;
+        }
 
 	for (i = 0; i < uwsgi.gateways_cnt; i++) {
 		if (uwsgi.gateways[i].pid > 0)
@@ -607,6 +627,14 @@ void grace_them_all(int signum) {
 
 
 	uwsgi_log("...gracefully killing workers...\n");
+
+	// unsubscribe if needed
+	struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
+        while(subscriptions) {
+                uwsgi_subscribe(subscriptions->value, 1);
+                subscriptions = subscriptions->next;
+        }
+
 	for (i = 1; i <= uwsgi.numproc; i++) {
 		if (uwsgi.auto_snapshot) {
 			if (uwsgi.workers[i].snapshot > 0) {
@@ -662,10 +690,12 @@ void reap_them_all(int signum) {
 		uwsgi.to_heaven = 1;
 	else uwsgi.to_outworld = 1;
 
-	for (i = 0; i < uwsgi.shared->daemons_cnt; i++) {
-		if (uwsgi.shared->daemons[i].pid > 0)
-			kill(-uwsgi.shared->daemons[i].pid, SIGKILL);
-	}
+	struct uwsgi_daemon *ud = uwsgi.daemons;
+        while(ud) {
+                if (ud->pid > 0)
+                        kill(-ud->pid, SIGKILL);
+                ud = ud->next;
+        }
 
 	for (i = 0; i < uwsgi.gateways_cnt; i++) {
 		if (uwsgi.gateways[i].pid > 0)
@@ -688,6 +718,14 @@ void reap_them_all(int signum) {
 		return;
 
 	uwsgi_log("...brutally killing workers...\n");
+
+	// unsubscribe if needed
+	struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
+        while(subscriptions) {
+                uwsgi_subscribe(subscriptions->value, 1);
+                subscriptions = subscriptions->next;
+        }
+
 	for (i = 1; i <= uwsgi.numproc; i++) {
 		if (uwsgi.workers[i].pid > 0)
 			kill(uwsgi.workers[i].pid, SIGTERM);
@@ -915,7 +953,7 @@ void fixup_argv_and_environ(int argc, char **argv, char **environ) {
 	int i;
 	int env_count = 0;
 
-	uwsgi.argv = uwsgi_malloc( sizeof(char *) * argc);
+	uwsgi.argv = uwsgi_malloc( sizeof(char *) * (argc+1));
 
 	for(i=0;i<argc;i++) {
 		if (i==0 || argv[0] + uwsgi.max_procname + 1 == argv[i]) {
@@ -924,6 +962,8 @@ void fixup_argv_and_environ(int argc, char **argv, char **environ) {
 		uwsgi.argv[i] = strdup(argv[i]);
 	}
 
+	// required by execve
+	uwsgi.argv[i+1] = NULL;
 	
 	uwsgi.max_procname++;
 
@@ -1046,6 +1086,9 @@ int main(int argc, char *argv[], char *envp[]) {
 	uwsgi.emperor_throttle = 1000;
 	uwsgi.emperor_pid = -1;
 
+	uwsgi.subscribe_freq = 10;
+	uwsgi.subscription_tolerance = 17;
+
 	uwsgi.cluster_fd = -1;
 	uwsgi.cores = 1;
 
@@ -1368,11 +1411,16 @@ int main(int argc, char *argv[], char *envp[]) {
 		uct = uct->next;
 	}
 
-	// second pass
+	// second pass: ENVs
+	uwsgi_apply_config_pass('$', (char *(*)(char *))getenv);
+
+	// third pass: FILEs
+	uwsgi_apply_config_pass('@', uwsgi_simple_file_read);
+
+	// last pass: REFERENCEs
 	uwsgi_apply_config_pass('%', uwsgi_get_exported_opt);
 
-	// third pass: ENVs
-	uwsgi_apply_config_pass('$', (char *(*)(char *))getenv);
+
 
 
 
@@ -1388,15 +1436,6 @@ int main(int argc, char *argv[], char *envp[]) {
 
 	/* uWSGI IS CONFIGURED !!! */
 
-	if (uwsgi.build_mime_dict) {
-		if (!access(uwsgi.mime_file, R_OK)) {
-			uwsgi_build_mime_dict(uwsgi.mime_file);
-		}
-		else {
-			uwsgi_log("!!! no mime.types file found !!!\n");
-		}
-	}
-
 	if (uwsgi.dump_options) {
 		struct option *lopt = uwsgi.long_options;
 		while (lopt->name) {
@@ -1420,48 +1459,7 @@ int main(int argc, char *argv[], char *envp[]) {
 	}
 
 
-#ifdef UWSGI_UDP
-	// get cluster configuration
-	if (uwsgi.cluster != NULL) {
-		// get multicast socket
-
-		uwsgi.cluster_fd = uwsgi_cluster_join(uwsgi.cluster);
-
-		uwsgi_log("JOINED CLUSTER: %s\n", uwsgi.cluster);
-
-		// ask for cluster options only if bot pre-existent options are set
-		if (uwsgi.exported_opts_cnt == 1 && !uwsgi.cluster_nodes) {
-			// now wait max 60 seconds and resend multicast request every 10 seconds
-			for (;;) {
-				uwsgi_log("asking \"%s\" uWSGI cluster for configuration data:\n", uwsgi.cluster);
-				if (uwsgi_send_empty_pkt(uwsgi.cluster_fd, uwsgi.cluster, 99, 0) < 0) {
-					uwsgi_log("unable to send multicast message to %s\n", uwsgi.cluster);
-					continue;
-				}
-			      waitfd:
-				rlen = uwsgi_waitfd(uwsgi.cluster_fd, 10);
-				if (rlen < 0) {
-					break;
-				}
-				else if (rlen > 0) {
-					// receive the packet
-					char clusterbuf[4096];
-					if (!uwsgi_hooked_parse_dict_dgram(uwsgi.cluster_fd, clusterbuf, 4096, 99, 1, manage_string_opt, NULL)) {
-						uwsgi_configure();
-						goto options_parsed;
-					}
-					else {
-						goto waitfd;
-					}
-				}
-			}
-		}
-	      options_parsed:
-
-		if (!uwsgi.cluster_nodes)
-			uwsgi_cluster_add_me();
-	}
-#endif
+	cluster_setup();
 
 	//call after_opt hooks
 
@@ -1469,27 +1467,26 @@ int main(int argc, char *argv[], char *envp[]) {
 		uwsgi.binary_path = uwsgi_str(uwsgi.argv[0]);
 	}
 
-	if (!uwsgi.no_initial_output) {
+
 		if (uwsgi.shared->options[UWSGI_OPTION_CGI_MODE] == 0) {
-			uwsgi_log("*** Starting uWSGI %s (%dbit) on [%.*s] ***\n", UWSGI_VERSION, (int) (sizeof(void *)) * 8, 24, ctime((const time_t *) &uwsgi.start_tv.tv_sec));
+			uwsgi_log_initial("*** Starting uWSGI %s (%dbit) on [%.*s] ***\n", UWSGI_VERSION, (int) (sizeof(void *)) * 8, 24, ctime((const time_t *) &uwsgi.start_tv.tv_sec));
 		}
 		else {
-			uwsgi_log("*** Starting uWSGI %s (CGI mode) (%dbit) on [%.*s] ***\n", UWSGI_VERSION, (int) (sizeof(void *)) * 8, 24, ctime((const time_t *) &uwsgi.start_tv.tv_sec));
+			uwsgi_log_initial("*** Starting uWSGI %s (CGI mode) (%dbit) on [%.*s] ***\n", UWSGI_VERSION, (int) (sizeof(void *)) * 8, 24, ctime((const time_t *) &uwsgi.start_tv.tv_sec));
 		}
 
 #ifdef UWSGI_DEBUG
 		uwsgi_log("***\n*** You are running a DEBUG version of uWSGI, please disable debug in your build profile and recompile it ***\n***\n");
 #endif
 
-		uwsgi_log("compiled with version: %s on %s\n", __VERSION__, UWSGI_BUILD_DATE);
+		uwsgi_log_initial("compiled with version: %s on %s\n", __VERSION__, UWSGI_BUILD_DATE);
 
 #ifdef __BIG_ENDIAN__
-		uwsgi_log("*** big endian arch detected ***\n");
+		uwsgi_log_initial("*** big endian arch detected ***\n");
 #endif
 
-	}
 
-	uwsgi_log("current working directory: %s\n", uwsgi.cwd);
+	uwsgi_log_initial("current working directory: %s\n", uwsgi.cwd);
 
 	if (uwsgi.screen_session) {
 		uwsgi_log("*** running under screen session %s ***\n", uwsgi.screen_session);
@@ -1508,7 +1505,7 @@ int main(int argc, char *argv[], char *envp[]) {
 		fclose(pidfile);
 	}
 
-	uwsgi_log("detected binary path: %s\n", uwsgi.binary_path);
+	uwsgi_log_initial("detected binary path: %s\n", uwsgi.binary_path);
 
 	struct uwsgi_socket *shared_sock = uwsgi.shared_sockets;
 	while (shared_sock) {
@@ -1657,11 +1654,9 @@ int uwsgi_start(void *v_argv) {
 		fclose(pidfile2);
 	}
 
-	if (!uwsgi.no_initial_output) {
 		if (!uwsgi.master_process) {
-			uwsgi_log("*** WARNING: you are running uWSGI without its master process manager ***\n");
+			uwsgi_log_initial("*** WARNING: you are running uWSGI without its master process manager ***\n");
 		}
-	}
 #ifndef __OpenBSD__
 
 	if (uwsgi.rl.rlim_max > 0) {
@@ -1686,16 +1681,14 @@ int uwsgi_start(void *v_argv) {
 	}
 	if (!getrlimit(RLIMIT_AS, &uwsgi.rl)) {
 		//check for overflow
-		if (uwsgi.rl.rlim_max != (rlim_t) RLIM_INFINITY && !uwsgi.no_initial_output) {
-			uwsgi_log("your process address space limit is %lld bytes (%lld MB)\n", (long long) uwsgi.rl.rlim_max, (long long) uwsgi.rl.rlim_max / 1024 / 1024);
+		if (uwsgi.rl.rlim_max != (rlim_t) RLIM_INFINITY) {
+			uwsgi_log_initial("your process address space limit is %lld bytes (%lld MB)\n", (long long) uwsgi.rl.rlim_max, (long long) uwsgi.rl.rlim_max / 1024 / 1024);
 		}
 	}
 #endif
 
 
-	if (!uwsgi.no_initial_output) {
-		uwsgi_log("your memory page size is %d bytes\n", uwsgi.page_size);
-	}
+		uwsgi_log_initial("your memory page size is %d bytes\n", uwsgi.page_size);
 
 	if (uwsgi.buffer_size > 65536) {
 		uwsgi_log("invalid buffer size.\n");
@@ -1703,6 +1696,15 @@ int uwsgi_start(void *v_argv) {
 	}
 	sanitize_args();
 
+	if (uwsgi.build_mime_dict) {
+		if (!access(uwsgi.mime_file, R_OK)) {
+			uwsgi_build_mime_dict(uwsgi.mime_file);
+		}
+		else {
+			uwsgi_log("!!! no mime.types file found !!!\n");
+		}
+	}
+
 	// end of generic initialization
 
 
@@ -1849,14 +1851,14 @@ int uwsgi_start(void *v_argv) {
 		uwsgi.timer_table_lock = uwsgi_mmap_shared_lock();
 		uwsgi_lock_init(uwsgi.timer_table_lock);
 
+		// probe table lock
+		uwsgi.probe_table_lock = uwsgi_mmap_shared_lock();
+		uwsgi_lock_init(uwsgi.probe_table_lock);
+
 		// rb_timer table lock
 		uwsgi.rb_timer_table_lock = uwsgi_mmap_shared_lock();
 		uwsgi_lock_init(uwsgi.rb_timer_table_lock);
 
-		// daemons table lock
-		uwsgi.daemon_table_lock = uwsgi_mmap_shared_lock();
-		uwsgi_lock_init(uwsgi.daemon_table_lock);
-
 		// cron table lock
 		uwsgi.cron_table_lock = uwsgi_mmap_shared_lock();
 		uwsgi_lock_init(uwsgi.cron_table_lock);
@@ -1896,17 +1898,9 @@ int uwsgi_start(void *v_argv) {
 		uwsgi_init_cache();
 	}
 
-	// attach startup daemons
-	if (uwsgi.master_process) {
-		for (i = 0; i < uwsgi.startup_daemons_cnt; i++) {
-			if (uwsgi_attach_daemon(uwsgi.startup_daemons[i])) {
-				uwsgi_log("!!! unable to attach daemon %s !!!\n", uwsgi.startup_daemons[i]);
-			}
-		}
-		// create the cache server
-		if (uwsgi.cache_server) {
-			uwsgi.cache_server_fd = uwsgi_cache_server(uwsgi.cache_server, uwsgi.cache_server_threads);
-		}
+	// create the cache server
+	if (uwsgi.master_process && uwsgi.cache_server) {
+		uwsgi.cache_server_fd = uwsgi_cache_server(uwsgi.cache_server, uwsgi.cache_server_threads);
 	}
 
 	/* plugin initialization */
@@ -2970,7 +2964,7 @@ void uwsgi_ignition() {
 static int manage_base_opt(int i, char *optarg) {
 
 	char *p;
-	struct uwsgi_static_map *usm, *old_usm;
+	char *docroot, *mountpoint;
 	struct uwsgi_config_template *uct, *old_uct;
 	struct uwsgi_cron *uc, *old_uc;
 	struct uwsgi_socket *uwsgi_sock = NULL;
@@ -3003,7 +2997,7 @@ static int manage_base_opt(int i, char *optarg) {
 		return 1;
 #ifdef UWSGI_UDP
 	case LONG_ARGS_CLUSTER_RELOAD:
-		send_udp_message(98, optarg, "", 0);
+		send_udp_message(98, 0, optarg, NULL, 0);
 		break;
 	case LONG_ARGS_CLUSTER_LOG:
 		uwsgi_stdin_sendto(optarg, 96, 0);
@@ -3244,12 +3238,8 @@ static int manage_base_opt(int i, char *optarg) {
 		uwsgi.mime_file = optarg;
 		return 1;
 	case LONG_ARGS_CHECK_STATIC:
-		uwsgi.check_static = realpath(optarg, NULL);
-		if (!uwsgi.check_static) {
-			uwsgi_error("check-static realpath()");
-			exit(1);
-		}
-		uwsgi.check_static_len = strlen(uwsgi.check_static);
+		uwsgi_dyn_dict_new(&uwsgi.check_static, optarg, strlen(optarg), NULL, 0);
+		uwsgi_log("[uwsgi-static] added check for %s\n", optarg);
 		uwsgi.build_mime_dict = 1;
 		return 1;
 	case LONG_ARGS_FILE_SERVE_MODE:
@@ -3350,45 +3340,17 @@ static int manage_base_opt(int i, char *optarg) {
 		uc->command = optarg+i;
 		return 1;
 	case LONG_ARGS_STATIC_MAP:
-		usm = uwsgi.static_maps;
-		if (!usm) {
-			usm = uwsgi_malloc(sizeof(struct uwsgi_static_map));
-			uwsgi.static_maps = usm;
-		}
-		else {
-			old_usm = usm;
-			while (usm->next) {
-				usm = usm->next;
-				old_usm = usm;
-			}
-
-			old_usm->next = uwsgi_malloc(sizeof(struct uwsgi_static_map));
-			usm = old_usm->next;
-		}
-
-		char *docroot = strchr(optarg, '=');
+		mountpoint = uwsgi_str(optarg);
+		docroot = strchr(mountpoint, '=');
 		if (!docroot) {
-			uwsgi_log("invalid document root in static map\n");
+			uwsgi_log("invalid document root in static map, syntax mountpoint=docroot\n");
 			exit(1);
 		}
-
-		usm->mountpoint = optarg;
-		usm->mountpoint_len = docroot - usm->mountpoint;
-
-		usm->document_root = realpath(docroot + 1, NULL);
-		if (!usm->document_root) {
-			uwsgi_error("static-map realpath()");
-			exit(1);
-		}
-		usm->document_root_len = strlen(usm->document_root);
-
-		usm->orig_document_root = usm->document_root;
-		usm->orig_document_root_len = usm->document_root_len;
-
-		uwsgi_log("static-mapped %.*s to %.*s\n", usm->mountpoint_len, usm->mountpoint, usm->document_root_len, usm->document_root);
+		docroot[0] = 0;
+		docroot++;
+		uwsgi_dyn_dict_new(&uwsgi.static_maps, mountpoint, strlen(mountpoint), docroot, strlen(docroot));
+		uwsgi_log("[uwsgi-static] added mapping for %s => %s\n", mountpoint, docroot);
 		uwsgi.build_mime_dict = 1;
-
-		usm->next = NULL;
 		return 1;
 	case LONG_ARGS_STOP:
 		signal_pidfile(SIGINT, optarg);
@@ -3400,17 +3362,18 @@ static int manage_base_opt(int i, char *optarg) {
 		signal_pidfile(SIGTSTP, optarg);
 		exit(0);
 	case LONG_ARGS_ATTACH_DAEMON:
-		if (uwsgi.startup_daemons_cnt < MAX_DAEMONS) {
-			uwsgi.startup_daemons[uwsgi.startup_daemons_cnt] = optarg;
-			uwsgi.startup_daemons_cnt++;
-		}
-		else {
-			uwsgi_log("you can specify at most %d --attach-daemons options\n", MAX_DAEMONS);
-		}
+		uwsgi_daemon_new(&uwsgi.daemons, optarg);
 		return 1;
 	case LONG_ARGS_SUBSCRIBE_TO:
 		uwsgi.master_process = 1;
 		uwsgi_string_new_list(&uwsgi.subscriptions, optarg);
+		uwsgi_log("[uwsgi-subscription] subscribed to %s\n", optarg);
+		return 1;
+	case LONG_ARGS_SUBSCR_TOLERANCE:
+		uwsgi.subscription_tolerance = atoi(optarg);
+		return 1;
+	case LONG_ARGS_SUBSCRIBE_FREQ:
+		uwsgi.subscribe_freq = atoi(optarg);
 		return 1;
 #ifdef __linux__
 	case LONG_ARGS_CGROUP:
@@ -3787,6 +3750,23 @@ static int manage_base_opt(int i, char *optarg) {
 			umask_mode = (umask_mode << 3) + (optarg[3] - '0');
 		}
 		umask(umask_mode);
+		return 1;
+	case LONG_ARGS_LOGFILE_CHMOD:
+                if (strlen(optarg) != 3) {
+                	uwsgi_log("invalid chmod value: %s\n", optarg);
+                        exit(1);
+               	}  
+                for (i = 0; i < 3; i++) {
+                	if (optarg[i] < '0' || optarg[i] > '7') {
+                        	uwsgi_log("invalid chmod value: %s\n", optarg);
+                                exit(1);
+                        }
+                }
+
+                uwsgi.chmod_logfile_value = (uwsgi.chmod_logfile_value << 3) + (optarg[0] - '0');
+                uwsgi.chmod_logfile_value = (uwsgi.chmod_logfile_value << 3) + (optarg[1] - '0');
+                uwsgi.chmod_logfile_value = (uwsgi.chmod_logfile_value << 3) + (optarg[2] - '0');
+
 		return 1;
 	case 'C':
 		uwsgi.chmod_socket = 1;
@@ -3840,17 +3820,17 @@ static int manage_base_opt(int i, char *optarg) {
 	return 0;
 }
 
-int _manage_opt(int i, char *p) {
+void manage_opt(int i, char *p) {
 	int j;
 
 	if (manage_base_opt(i, p)) {
-                        return 1;
+                        return;
                 }
 
                 for (j = 0; j < 0xFF; j++) {
                         if (uwsgi.p[j]->manage_opt) {
                                 if (uwsgi.p[j]->manage_opt(i, p)) {
-                                        return 1;
+                                        return;
                                 }
                         }
                 }
@@ -3858,124 +3838,15 @@ int _manage_opt(int i, char *p) {
                 for (j = 0; j < uwsgi.gp_cnt; j++) {
                         if (uwsgi.gp[j]->manage_opt) {
                                 if (uwsgi.gp[j]->manage_opt(i, p)) {
-                                        return 1;
+                                        return;
                                 }
                         }
                 }
 
-	return 0;
+	// never here
+	exit(1);
 }
 
-void manage_opt(int i, char *optarg) {
-
-	char *value = optarg;
-
-	if (value && strchr(optarg, ';')) {
-		value = uwsgi_str(optarg);
-		if (value[0] == '\\') {
-			if (!_manage_opt(i, value+1)) {
-				exit(1);
-			}
-			return;
-		}
-	}
-
-	if (!value) {
-		if (!_manage_opt(i, NULL)) {
-			exit(1);
-		}
-		return;
-	}
-
-	char *p = strtok(value, ";");
-	while(p != NULL) {
-
-		if (_manage_opt(i, p)) goto next;
-		exit(1);
-next:
-		p = strtok(NULL, ";");
-		
-	}
-
-	return;
-
-}
-
-void uwsgi_cluster_add_node(struct uwsgi_cluster_node *nucn, int type) {
-
-	int i;
-	struct uwsgi_cluster_node *ucn;
-	char *tcp_port;
-
-#ifdef UWSGI_DEBUG
-	uwsgi_log("adding node\n");
-#endif
-
-	tcp_port = strchr(nucn->name, ':');
-#ifndef UWSGI_ZEROMQ
-	if (tcp_port == NULL) {
-#else
-	char *zmq_dash = strchr(nucn->name, '-');
-	if (tcp_port == NULL && zmq_dash == NULL) {
-#endif
-
-		fprintf(stdout, "invalid cluster node name %s\n", nucn->name);
-		return;
-	}
-
-	// first check for already present node
-	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-		ucn = &uwsgi.shared->nodes[i];
-		if (ucn->name[0] != 0) {
-			if (!strcmp(ucn->name, nucn->name)) {
-				ucn->status = UWSGI_NODE_OK;
-				ucn->last_seen = time(NULL);
-				// update requests
-				ucn->requests = nucn->requests;
-				return;
-			}
-		}
-	}
-
-	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-		ucn = &uwsgi.shared->nodes[i];
-
-		if (ucn->name[0] == 0) {
-			memcpy(ucn->name, nucn->name, strlen(nucn->name) + 1);
-			memcpy(ucn->nodename, nucn->nodename, strlen(nucn->nodename) + 1);
-			ucn->workers = nucn->workers;
-			ucn->ucn_addr.sin_family = AF_INET;
-			if (tcp_port) {
-				ucn->ucn_addr.sin_port = htons(atoi(tcp_port + 1));
-				tcp_port[0] = 0;
-			}
-			if (nucn->name[0] == 0) {
-				ucn->ucn_addr.sin_addr.s_addr = INADDR_ANY;
-			}
-			else {
-#ifdef UWSGI_DEBUG
-				uwsgi_log("%s\n", nucn->name);
-#endif
-				ucn->ucn_addr.sin_addr.s_addr = inet_addr(nucn->name);
-			}
-
-			ucn->type = type;
-			// here memory can be freed, as it is allocated by uwsgi_concat2n
-			if (type != CLUSTER_NODE_DYNAMIC && tcp_port) {
-				tcp_port[0] = ':';
-			}
-			ucn->last_seen = time(NULL);
-			ucn->requests = nucn->requests;
-			uwsgi_log("[uWSGI cluster] added node %s\n", ucn->name);
-			return;
-		}
-	}
-
-	uwsgi_log("unable to add node %s\n", nucn->name);
-}
-
-
-
 void build_options() {
 	int i;
 	struct option *lopt, *aopt;
@@ -4106,177 +3977,14 @@ void manage_string_opt(char *key, uint16_t keylen, char *val, uint16_t vallen, v
 	add_exported_option(key2, val2, 0);
 }
 
-#ifdef UWSGI_UDP
-int uwsgi_cluster_add_me() {
-
-	const char *key1 = "hostname";
-	const char *key2 = "address";
-	const char *key3 = "workers";
-	const char *key4 = "requests";
-
-	char *ptrbuf;
-	uint16_t ustrlen;
-	char numproc[6];
-
-#ifdef UWSGI_ZEROMQ
-	char uuid_zmq_str[37];
-	uuid_t uuid_zmq;
-	if (!uwsgi.sockets && !uwsgi.zeromq) {
-#else
-	if (!uwsgi.sockets) {
-#endif
-		uwsgi_log("you need to specify at least a socket to start a uWSGI cluster\n");
-		exit(1);
-	}
-
-	snprintf(numproc, 6, "%d", uwsgi.numproc);
-
-	size_t len;
-
-	if (uwsgi.sockets) {
-		len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key2) + 2 + strlen(uwsgi.sockets->name) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
-	}
-#ifdef UWSGI_ZEROMQ
-	else if (uwsgi.zeromq) {
-                uuid_generate(uuid_zmq);
-                uuid_unparse(uuid_zmq, uuid_zmq_str);
-		len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key2) + 2 + strlen(uuid_zmq_str) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
-	}
-#endif
-	else {
-		len = 2 + strlen(key1) + 2 + strlen(uwsgi.hostname) + 2 + strlen(key3) + 2 + strlen(numproc) + 2 + strlen(key4) + 2 + 1;
-	}
-	char *buf = uwsgi_malloc(len);
-
-	ptrbuf = buf;
-
-	ustrlen = strlen(key1);
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, key1, strlen(key1));
-	ptrbuf += strlen(key1);
-
-	ustrlen = strlen(uwsgi.hostname);
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, uwsgi.hostname, strlen(uwsgi.hostname));
-	ptrbuf += strlen(uwsgi.hostname);
-
-
-	if (uwsgi.sockets && uwsgi.sockets->name) {
-		ustrlen = strlen(key2);
-		*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-		*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-		memcpy(ptrbuf, key2, strlen(key2));
-		ptrbuf += strlen(key2);
-
-		ustrlen = strlen(uwsgi.sockets->name);
-		*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-		*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-		memcpy(ptrbuf, uwsgi.sockets->name, strlen(uwsgi.sockets->name));
-		ptrbuf += strlen(uwsgi.sockets->name);
-	}
-#ifdef UWSGI_ZEROMQ
-	else if (uwsgi.zeromq) {
-		ustrlen = strlen(key2);
-		*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-		*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-		memcpy(ptrbuf, key2, strlen(key2));
-		ptrbuf += strlen(key2);
-
-		ustrlen = strlen(uuid_zmq_str);
-		*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-		*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-		memcpy(ptrbuf, uuid_zmq_str, strlen(uuid_zmq_str));
-		ptrbuf += strlen(uuid_zmq_str);
-	}
-#endif
-
-
-	ustrlen = strlen(key3);
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, key3, strlen(key3));
-	ptrbuf += strlen(key3);
-
-	ustrlen = strlen(numproc);
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, numproc, strlen(numproc));
-	ptrbuf += strlen(numproc);
-
-	ustrlen = strlen(key4);
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, key4, strlen(key4));
-	ptrbuf += strlen(key4);
-
-	ustrlen = 1;
-	*ptrbuf++ = (uint8_t) (ustrlen & 0xff);
-	*ptrbuf++ = (uint8_t) ((ustrlen >> 8) & 0xff);
-	memcpy(ptrbuf, "0", 1);
-	ptrbuf += 1;
-
-
-	uwsgi_string_sendto(uwsgi.cluster_fd, 95, 0, (struct sockaddr *) &uwsgi.mc_cluster_addr, sizeof(uwsgi.mc_cluster_addr), buf, len);
-
-	free(buf);
-
-#ifdef UWSGI_DEBUG
-	uwsgi_log("add_me() successfull\n");
-#endif
-
-	return 0;
-}
-
-int uwsgi_cluster_join(char *name) {
-
-	int fd;
-	char *cp;
-	int broadcast = 0;
-
-
-	
-	if (name[0] == ':') {
-		fd = bind_to_udp(name, 0, 1);
-		broadcast = 1;
-	}
-	else {
-		fd = bind_to_udp(name, 1, 0);
-	}
-
-	if (fd >= 0) {
-		cp = strchr(name, ':');
-		cp[0] = 0;
-		uwsgi.mc_cluster_addr.sin_family = AF_INET;
-		if (broadcast) {
-			uwsgi.mc_cluster_addr.sin_addr.s_addr = INADDR_BROADCAST;
-		}
-		else {
-			uwsgi.mc_cluster_addr.sin_addr.s_addr = inet_addr(name);
-		}
-		uwsgi.mc_cluster_addr.sin_port = htons(atoi(cp + 1));
-		cp[0] = ':';
-
-
-		// announce my presence to all the nodes
-		uwsgi_string_sendto(fd, 73, 0, (struct sockaddr *) &uwsgi.mc_cluster_addr, sizeof(uwsgi.mc_cluster_addr), uwsgi.hostname, strlen(uwsgi.hostname));
-	}
-	else {
-		exit(1);
-	}
-
-
-	return fd;
-
-}
 
 void uwsgi_stdin_sendto(char *socket_name, uint8_t modifier1, uint8_t modifier2) {
 
 	char buf[4096];
 	ssize_t rlen;
-	size_t delta = 4096;
-	char *ptr = buf;
+	size_t delta = 4096-4;
+	// leave space for uwsgi header
+	char *ptr = buf+4;
 
 	rlen = read(0, ptr, delta);
 	while (rlen > 0) {
@@ -4288,43 +3996,14 @@ void uwsgi_stdin_sendto(char *socket_name, uint8_t modifier1, uint8_t modifier2)
 		rlen = read(0, ptr, delta);
 	}
 
-	if (ptr > buf) {
-		send_udp_message(modifier1, socket_name, buf, ptr - buf);
-		uwsgi_log("sent string \"%.*s\" to cluster node %s", ptr - buf, buf, socket_name);
+	if (ptr > buf+4) {
+		send_udp_message(modifier1, modifier2, socket_name, buf, (ptr - buf)-4);
+		uwsgi_log("sent string \"%.*s\" to cluster node %s", (ptr - buf)-4, buf+4, socket_name);
 	}
 
 }
-#endif
 
 
-char *uwsgi_cluster_best_node() {
-
-	int i;
-	int best_node = -1;
-	struct uwsgi_cluster_node *ucn;
-
-	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-		ucn = &uwsgi.shared->nodes[i];
-		if (ucn->name[0] != 0 && ucn->status == UWSGI_NODE_OK) {
-			if (best_node == -1) {
-				best_node = i;
-			}
-			else {
-				if (ucn->last_choosen < uwsgi.shared->nodes[best_node].last_choosen) {
-					best_node = i;
-				}
-			}
-		}
-	}
-
-	if (best_node == -1) {
-		return NULL;
-	}
-
-	uwsgi.shared->nodes[best_node].last_choosen = time(NULL);
-	return uwsgi.shared->nodes[best_node].name;
-}
-
 
 struct uwsgi_help_item main_help[] = {
 

uwsgi.h

@@ -11,6 +11,7 @@ extern "C" {
 #define UMAX64_STR "18446744073709551616"
 
 #define uwsgi_error(x)  uwsgi_log("%s: %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
+#define uwsgi_log_initial if (!uwsgi.no_initial_output) uwsgi_log
 #define uwsgi_fatal_error(x) uwsgi_error(x); exit(1);
 #define uwsgi_error_open(x)  uwsgi_log("open(\"%s\"): %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
 #define uwsgi_req_error(x)  if (wsgi_req->uri_len > 0 && wsgi_req->method_len > 0 && wsgi_req->remote_addr_len > 0) uwsgi_log_verbose("%s: %s [%s line %d] during %.*s %.*s (%.*s)\n", x, strerror(errno), __FILE__, __LINE__,\
@@ -38,7 +39,8 @@ extern "C" {
 #define MAX_GENERIC_PLUGINS 64
 #define MAX_RPC 64
 #define MAX_GATEWAYS 64
-#define MAX_DAEMONS 8
+#define MAX_TIMERS 64
+#define MAX_PROBES 64
 #define MAX_CRONS 64
 
 #ifndef UWSGI_LOAD_EMBEDDED_PLUGINS
@@ -272,20 +274,6 @@ struct uwsgi_config_template {
 	struct uwsgi_config_template *next;
 };
 
-struct uwsgi_static_map {
-
-	char *mountpoint;
-	int mountpoint_len;
-
-	char *document_root;
-	int document_root_len;
-
-	char *orig_document_root;
-	int orig_document_root_len;
-
-	struct uwsgi_static_map *next;
-};
-
 struct uwsgi_string_list {
 
 	char *value;
@@ -302,6 +290,7 @@ struct uwsgi_dyn_dict {
 	int vallen;
 
 	uint64_t hits;
+	int status;
 
 	struct uwsgi_dyn_dict *prev;
 	struct uwsgi_dyn_dict *next;
@@ -338,8 +327,8 @@ struct uwsgi_gateway {
 // Daemons are external processes maintained by the master
 
 struct uwsgi_daemon {
-	char command[0xff];
-	char tmp_command[0xff];
+	char *command;
+	char *tmp_command;
 	pid_t pid;
 	uint64_t respawns;
 	time_t born;
@@ -347,6 +336,8 @@ struct uwsgi_daemon {
 	int status;
 	int registered;
 	//int pipe[2];
+
+	struct uwsgi_daemon *next;
 };
 
 struct uwsgi_queue_header {
@@ -541,6 +532,9 @@ struct uwsgi_opt {
 #define LONG_ARGS_SIGNAL_BUFSIZE	17162
 #define LONG_ARGS_SIGNAL		17163
 #define LONG_ARGS_KSM			17164
+#define LONG_ARGS_LOGFILE_CHMOD		17165
+#define LONG_ARGS_SUBSCRIBE_FREQ	17166
+#define LONG_ARGS_SUBSCR_TOLERANCE	17167
 
 
 #define UWSGI_OK	0
@@ -974,6 +968,34 @@ struct uwsgi_signal_rb_timer {
 	struct uwsgi_rb_timer *uwsgi_rb_timer;
 };
 
+struct uwsgi_signal_probe {
+	
+	int (*func)(int, struct uwsgi_signal_probe *);
+	char args[1024];
+
+	int fd;
+	int state;
+	int bad;
+	int last_event;
+	void *data;
+	uint64_t cycles;
+
+	int timeout;
+	int freq;
+
+	int registered;
+	uint8_t sig;
+};
+
+struct uwsgi_probe {
+
+	char *name;
+	int (*func)(int, struct uwsgi_signal_probe *);
+
+	struct uwsgi_probe *next;
+};
+
+
 struct uwsgi_server {
 
 
@@ -1163,13 +1185,17 @@ struct uwsgi_server {
 
 
 	// static file serving
-	char *check_static;
-	size_t check_static_len;
 	int file_serve_mode;
-
 	int build_mime_dict;
 	char *mime_file;
-	struct uwsgi_static_map *static_maps;
+
+	struct uwsgi_probe *probes;
+
+	struct uwsgi_daemon *daemons;
+	int daemons_cnt;
+
+	struct uwsgi_dyn_dict *static_maps;
+	struct uwsgi_dyn_dict *check_static;
 	struct uwsgi_dyn_dict *mimetypes;
 
 	char *logfile;
@@ -1328,6 +1354,7 @@ struct uwsgi_server {
 	int chmod_socket;
 	char *chown_socket;
 	mode_t chmod_socket_value;
+	mode_t chmod_logfile_value;
 	int listen_queue;
 
 #ifdef UWSGI_XML
@@ -1510,6 +1537,7 @@ struct uwsgi_server {
 	void *signal_table_lock;
 	void *fmon_table_lock;
 	void *timer_table_lock;
+	void *probe_table_lock;
 	void *rb_timer_table_lock;
 	void *cron_table_lock;
 	void *rpc_table_lock;
@@ -1518,12 +1546,9 @@ struct uwsgi_server {
 	void *spooler_lock;
 #endif
 
-	void *daemon_table_lock;
-
-	char *startup_daemons[MAX_DAEMONS];
-	int startup_daemons_cnt;
-
 	// subscription client
+	int subscribe_freq;
+	int subscription_tolerance;
 	struct uwsgi_string_list *subscriptions;
 
 #ifdef __linux__
@@ -1659,10 +1684,13 @@ struct uwsgi_shared {
 	struct uwsgi_fmon files_monitored[64];
 	int files_monitored_cnt;
 
-	struct uwsgi_timer timers[64];
+	struct uwsgi_signal_probe probes[MAX_PROBES];
+	int probes_cnt;
+
+	struct uwsgi_timer timers[MAX_TIMERS];
 	int timers_cnt;
 
-	struct uwsgi_signal_rb_timer rb_timers[64];
+	struct uwsgi_signal_rb_timer rb_timers[MAX_TIMERS];
 	int rb_timers_cnt;
 
 	struct uwsgi_rpc rpc_table[MAX_RPC];
@@ -1670,8 +1698,6 @@ struct uwsgi_shared {
 
 	int worker_log_pipe[2];
 
-	struct uwsgi_daemon daemons[MAX_DAEMONS];
-	int daemons_cnt;
 #ifdef __linux__
 	struct tcp_info ti;
 #endif
@@ -1717,6 +1743,7 @@ struct uwsgi_worker {
 	uint64_t respawn_count;
 
 	uint64_t requests;
+	uint64_t delta_requests;
 	uint64_t failed_requests;
 
 	time_t harakiri;
@@ -1854,7 +1881,7 @@ uint64_t uwsgi_swap64(uint64_t);
 #endif
 
 #ifdef UWSGI_UDP
-ssize_t send_udp_message(uint8_t, char *, char *, uint16_t);
+ssize_t send_udp_message(uint8_t, uint8_t, char *, char *, uint16_t);
 #endif
 
 int uwsgi_parse_packet(struct wsgi_request *, int);
@@ -2108,7 +2135,6 @@ ssize_t fcgi_send_record(int, uint8_t, uint16_t, char *);
 ssize_t fcgi_send_param(int, char *, uint16_t, char *, uint16_t);
 uint16_t fcgi_get_record(int, char *);
 
-int uwsgi_attach_daemon(char *);
 void spawn_daemon(struct uwsgi_daemon *);
 
 void emperor_loop(void);
@@ -2251,7 +2277,7 @@ int uwsgi_netlink_del(char *);
 int uwsgi_amqp_consume_queue(int, char *, char *, char *, char *, char *, char *);
 char *uwsgi_amqp_consume(int, uint64_t *, char **);
 
-int uwsgi_file_serve(struct wsgi_request *, char *, uint16_t, char *, uint16_t, char *, uint16_t);
+int uwsgi_file_serve(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
 inline int uwsgi_starts_with(char *, int, char *, int);
 
 #ifdef __sun__
@@ -2425,6 +2451,9 @@ struct uwsgi_subscribe_node {
 	uint64_t requests;
 	uint64_t transferred;
 
+	int death_mark;
+	uint64_t reference;
+
 	struct uwsgi_subscribe_slot *slot;
 
         struct uwsgi_subscribe_node *next;
@@ -2455,8 +2484,9 @@ void mule_send_msg(int, char *, size_t);
 
 void create_signal_pipe(int *);
 struct uwsgi_subscribe_slot *uwsgi_get_subscribe_slot(struct uwsgi_subscribe_slot **, char *, uint16_t, int);
+struct uwsgi_subscribe_node *uwsgi_get_subscribe_node_by_name(struct uwsgi_subscribe_slot **, char *, uint16_t, char *, uint16_t, int);
 struct uwsgi_subscribe_node *uwsgi_get_subscribe_node(struct uwsgi_subscribe_slot **, char *, uint16_t, int);
-void uwsgi_remove_subscribe_node(struct uwsgi_subscribe_slot **, struct uwsgi_subscribe_node *);
+int uwsgi_remove_subscribe_node(struct uwsgi_subscribe_slot **, struct uwsgi_subscribe_node *);
 struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slot **, struct uwsgi_subscribe_req *, int);
 
 ssize_t uwsgi_mule_get_msg(int, int, char *, size_t, int);
@@ -2466,6 +2496,24 @@ void uwsgi_add_app(int, uint8_t, char *, int);
 int uwsgi_signal_send(int, uint8_t);
 int uwsgi_remote_signal_send(char *, uint8_t); 
 
+void uwsgi_configure(void);
+void cluster_setup(void);
+void manage_cluster_announce(char *, uint16_t, char *, uint16_t, void *);
+
+int uwsgi_read_response(int, struct uwsgi_header *, int, char **);
+char *uwsgi_simple_file_read(char *);
+
+void uwsgi_send_subscription(char *, char *, size_t , char *, size_t, uint8_t);
+
+void uwsgi_subscribe(char *, uint8_t);
+
+struct uwsgi_daemon *uwsgi_daemon_new(struct uwsgi_daemon **, char *);
+
+struct uwsgi_probe *uwsgi_probe_register(struct uwsgi_probe **, char *, int (*)(int, struct uwsgi_signal_probe *));
+int uwsgi_add_probe(uint8_t sig, char *, char *, int, int);
+
+int uwsgi_is_bad_connection(int);
+
 #ifdef __linux__
 #ifdef MADV_MERGEABLE
 void uwsgi_linux_ksm_map(void);

uwsgiconfig.py

@@ -99,7 +99,7 @@ def compile(cflags, objfile, srcfile):
     except:
         pass
     cmdline = "%s -c %s -o %s %s" % (GCC, cflags, objfile, srcfile)
-    print(cmdline)
+    print("[%s] %s" % (GCC, objfile))
     ret = os.system(cmdline)
     if ret != 0:
         sys.exit(1)
@@ -126,6 +126,8 @@ def build_uwsgi(uc):
         cflags.append(epc)
         cflags.append(eplc)
 
+    print("configured CFLAGS: %s" % ' '.join(cflags))
+
     print("*** uWSGI compiling server core ***")
     for file in gcc_list:
         objfile = file
@@ -237,17 +239,25 @@ class uConf(object):
 
         self.config.read(filename)
         self.gcc_list = ['utils', 'protocol', 'socket', 'logging', 'master', 'master_utils', 'emperor', 'notify', 'mule', 'subscription',
-            'plugins', 'lock', 'cache', 'queue', 'event', 'signal', 'rpc', 'gateway', 'loop', 'lib/rbtree', 'lib/amqp', 'rb_timers', 'uwsgi']
+            'plugins', 'lock', 'cache', 'queue', 'event', 'signal', 'cluster', 'rpc', 'gateway', 'loop', 'lib/rbtree', 'lib/amqp', 'rb_timers', 'uwsgi']
         # add protocols
         self.gcc_list.append('proto/base')
         self.gcc_list.append('proto/uwsgi')
         self.gcc_list.append('proto/http')
         self.gcc_list.append('proto/fastcgi')
         self.include_path = []
+
+        self.cflags = ['-O2', '-Wall', '-Werror', '-D_LARGEFILE_SOURCE', '-D_FILE_OFFSET_BITS=64'] + os.environ.get("CFLAGS", "").split()
+
         if uwsgi_os == 'Linux':
             self.gcc_list.append('lib/linux_ns')
             self.gcc_list.append('lib/netlink')
-        self.cflags = ['-O2', '-Wall', '-Werror', '-D_LARGEFILE_SOURCE', '-D_FILE_OFFSET_BITS=64'] + os.environ.get("CFLAGS", "").split()
+            try:
+                lk_ver = uwsgi_os_k.split('.')
+                if int(lk_ver[0]) <= 2 and int(lk_ver[1]) <= 6 and int(lk_ver[2]):
+                    self.cflags.append('-DOBSOLETE_LINUX_KERNEL')                    
+            except:
+                pass
 
         try:
             gcc_version = str(spcall("%s -dumpversion" % GCC))
@@ -803,7 +813,7 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
     #    gcc_list.insert(0,ofile)
 
     gccline = "%s -fPIC %s -o %s.so %s %s %s %s" % (GCC, shared_flag, plugin_dest, ' '.join(p_cflags), ' '.join(p_ldflags), ' '.join(gcc_list), ' '.join(p_libs) )
-    print(gccline)
+    print("[%s] %s.so" % (GCC, plugin_dest))
 
     ret = os.system(gccline)
     if ret != 0:
@@ -854,6 +864,7 @@ if __name__ == "__main__":
             name = sys.argv[4]
         except:
             name = None
+        print("*** uWSGI building and linking plugin %s ***" % sys.argv[2] )
         build_plugin(sys.argv[2], uc, cflags, ldflags, libs, name)
     elif cmd == '--clean':
         os.system("rm -f *.o")

welcome.py

@@ -59,7 +59,10 @@ def application(env, start_response):
 
     uwsgi.setprocname("worker %d managed %d requests" % (uwsgi.worker_id(), req))
 
-    gc.collect(2)
+    try:
+        gc.collect(2)
+    except:
+        pass
     if DEBUG:
         print(env['wsgi.input'].fileno())
 
@@ -71,7 +74,10 @@ def application(env, start_response):
     if DEBUG:
         print(env['wsgi.input'].fileno())
 
-    gc.collect(2)
+    try:
+        gc.collect(2)
+    except:
+        pass
 
     if DEBUG:
         print(len(gc.get_objects()))