various erlang fixes

.hgtags

@@ -31,3 +31,8 @@ f4d3c4dcd7a63e21fcc9d8d567374c69935178bd 0.9.8.3
 6945ee03c7ea95eb19217ef1e1fb17d9ae26adbc 0.9.9-beta1
 fb168b0b86169219aa9b8e40f0caa6297cf34dbc 0.9.9-rc1
 6aa667612019fcff8e68af9469f73aff6fa378a8 0.9.9-rc2
+376ffd8f190623e5e2521fe9fa64bf03c31e71be 0.9.9
+7048ae11cfc8453c6bb599af3c0dfacd7ebae43c 1.0-rc1
+7a4e021ea7ba2953e474326612c3bb82d6817f0e 1.0-rc2
+4e4e781ef89ac33e71a7e92741d54549240ed156 1.0-rc3
+24f7e260ea345c2cd73e2fd8191dddbd1b039062 1.0-rc4

CONTRIBUTORS

@@ -12,3 +12,5 @@ Marco Beri, Link I.T. S.p.a.
 Leonid Borisenko
 Cal Leeming, Simplicity Media Ltd
 Luigi Scarso
+Corey Farwell
+Charles Duffy

bootstrap.py

@@ -1,4 +1,5 @@
 import sys
 import uwsgi
 
+print("i am the bootstrap for uwsgi.SymbolsImporter")
 sys.meta_path.insert(0, uwsgi.SymbolsImporter())

bootstrap5.py

@@ -0,0 +1,3 @@
+import uwsgi
+
+print uwsgi.extract("data://0")

buildconf/default.ini

@@ -27,7 +27,7 @@ plugins =
 bin_name = uwsgi
 append_version =
 plugin_dir = .
-embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, ugreen
+embedded_plugins = python, ping, cache, nagios, rrdtool, rpc, fastrouter, http, ugreen
 as_shared_library = false
 
 locking = auto

buildconf/pyuwsgi.ini

@@ -0,0 +1,5 @@
+[uwsgi]
+inherit = default
+bin_name = pyuwsgi.so
+embedded_plugins = pyuwsgi,python,ping,cache,nagios,rpc,ugreen
+as_shared_library = true

cache.c

@@ -94,151 +94,6 @@ void uwsgi_init_cache() {
                 uwsgi_log("*** Cache subsystem initialized: %dMB preallocated ***\n", ((sizeof(uint64_t) * UMAX16) + (sizeof(uint64_t) * uwsgi.cache_max_items) + (uwsgi.cache_blocksize * uwsgi.cache_max_items) + (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items)) / (1024 * 1024));
 }
 
-struct uwsgi_subscriber_name *uwsgi_get_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen) {
-
-	uint64_t ovl;
-	struct uwsgi_subscriber *usub;
-	struct uwsgi_subscriber_name *ret = NULL;
-	
-	usub = (struct uwsgi_subscriber *) uwsgi_dict_get(udict, key, keylen, &ovl);
-
-	if (usub == NULL || !ovl) return NULL;
-
-	if (!usub->nodes) return NULL;
-
-	if (usub && ovl) {
-		ret = &usub->names[usub->current];
-		// dead node
-		if (ret->len == 0) {
-			if (usub->current == usub->nodes-1) {
-				usub->nodes--;
-			}
-			// retry with another node (if available)
-			if (usub->nodes > 0) {
-				usub->current++;
-				if (usub->current >= usub->nodes) usub->current = 0;
-				return uwsgi_get_subscriber(udict, key, keylen);
-			}
-		}
-
-		if (usub->nodes > 1) {
-			usub->current++;
-			if (usub->current >= usub->nodes) usub->current = 0;
-		}
-
-	}
-
-	return ret;
-}
-
-void uwsgi_add_subscriber(struct uwsgi_dict *udict, struct uwsgi_subscribe_req *usr) {
-
-	char *ptr;
-	uint64_t vallen = 0;
-	struct uwsgi_subscriber *usub, nusub;
-	int found = 0;
-	int i;
-	
-	ptr = uwsgi_dict_get(udict, usr->key, usr->keylen, &vallen);
-	if (ptr && vallen) {
-		usub = (struct uwsgi_subscriber *) ptr;
-		for(i=0;i<(int)usub->nodes;i++) {
-			if (!uwsgi_strncmp(usub->names[i].name, usub->names[i].len, usr->address, usr->address_len)) {
-				found = 1;
-				break;
-			}
-		}
-		if (!found) {
-			found = usub->nodes;
-			// check for unallocated slot
-			for(i=0;i<(int)usub->nodes;i++) {
-				if (usub->names[i].len == 0) {
-					found = i;
-					break;
-				}
-			}
-			usub->names[found].len = usr->address_len;
-			usub->names[found].modifier1 = usr->modifier1;
-			usub->names[found].modifier2 = usr->modifier2;
-			memcpy(usub->names[found].name, usr->address, usr->address_len);
-			if (found == (int) usub->nodes) {
-				usub->nodes++;
-			}
-		}
-		return;
-	}
-	else {
-		nusub.nodes = 1;
-		nusub.current = 0;
-		memcpy(nusub.names[0].name, usr->address, usr->address_len);
-		nusub.names[0].modifier1 = usr->modifier1;
-		nusub.names[0].modifier2 = usr->modifier2;
-		uwsgi_dict_set(udict, usr->key, usr->keylen, (char *) &nusub, sizeof(struct uwsgi_subscriber));
-	}
-
-}
-
-struct uwsgi_dict *uwsgi_dict_create(uint64_t items, uint64_t blocksize) {
-
-	int i;
-
-	struct uwsgi_dict *udict = (struct uwsgi_dict *) mmap(NULL, sizeof(uint64_t) * UMAX16, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-	if (!udict) {
-        	uwsgi_error("mmap()");
-                exit(1);
-	}
-
-	if (!blocksize) blocksize = 4096;
-
-        if (blocksize % uwsgi.page_size != 0) {
-        	uwsgi_log("invalid shared dictionary blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) udict->blocksize, uwsgi.page_size);
-        	exit(1);
-	}
-
-	udict->blocksize = blocksize;
-	udict->max_items = items;
-
-        udict->hashtable = (uint64_t *) mmap(NULL, sizeof(uint64_t) * UMAX16, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-        if (!udict->hashtable) {
-        	uwsgi_error("mmap()");
-                exit(1);
-	}
-
-        memset(udict->hashtable, 0, sizeof(uint64_t) * UMAX16);
-
-        udict->unused_stack = (uint64_t *) mmap(NULL, sizeof(uint64_t) * udict->max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-        if (!udict->unused_stack) {
-        	uwsgi_error("mmap()");
-                exit(1);
-	}
-
-        memset(udict->unused_stack, 0, sizeof(uint64_t) * udict->max_items);
-
-        udict->items = (struct uwsgi_dict_item *) mmap(NULL, sizeof(struct uwsgi_dict_item) * udict->max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-        if (!udict->items) {
-        	uwsgi_error("mmap()");
-                exit(1);
-        }
-
-        udict->data = mmap(NULL, udict->blocksize * udict->max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-        if (!udict->data) {
-        	uwsgi_error("mmap()");
-                exit(1);
-        }
-
-        for(i=0;i< (int) udict->max_items;i++) {
-        	memset(&udict->items[i], 0, sizeof(struct uwsgi_dict_item));
-        }
-
-        udict->first_available_item = 1;
-        udict->unused_stack_ptr = 0;
-
-        udict->lock = uwsgi_mmap_shared_lock();
-        uwsgi_lock_init(udict->lock);
-
-	return udict;
-}
-
 uint32_t djb33x_hash(char *key, int keylen) {
 
 	register uint32_t hash = 5381;
@@ -252,89 +107,6 @@ uint32_t djb33x_hash(char *key, int keylen) {
 }
 
 
-inline uint64_t uwsgi_dict_get_index(struct uwsgi_dict *udict, char *key, uint16_t keylen) {
-
-        uint32_t hash = djb33x_hash(key, keylen);
-
-        int hash_key = hash % 0xffff;
-
-        uint64_t slot = udict->hashtable[hash_key];
-
-        struct uwsgi_dict_item *udi;
-
-        udi = &udict->items[slot];
-
-        // first round
-        if (udi->djbhash != hash) goto cycle;
-        if (udi->keysize != keylen) goto cycle;
-        if (memcmp(udi->key, key, keylen)) goto cycle;
-
-        return slot;
-
-cycle:
-        while(udi->next) {
-                slot = udi->next;
-                udi = &udict->items[slot];
-                if (udi->djbhash != hash) continue;
-                if (udi->keysize != keylen) continue;
-                if (!memcmp(udi->key, key, keylen)) return slot;
-        }
-
-        return 0;
-}
-
-char *uwsgi_dict_get(struct uwsgi_dict *udict, char *key, uint16_t keylen, uint64_t *valsize) {
-
-        uint64_t index = uwsgi_dict_get_index(udict, key, keylen);
-
-        if (index) {
-                *valsize = udict->items[index].valsize;
-                udict->items[index].hits++;
-                return udict->data+(index*udict->blocksize);
-        }
-
-        return NULL;
-}
-
-int uwsgi_dict_del(struct uwsgi_dict *udict, char *key, uint16_t keylen) {
-
-        uint64_t index = 0;
-        struct uwsgi_dict_item *udi;
-        int ret = -1;
-
-        index = uwsgi_dict_get_index(udict, key, keylen);
-        if (index) {
-                udi = &udict->items[index] ;
-                udi->keysize = 0;
-                udi->valsize = 0;
-                udict->unused_stack_ptr++;
-                udict->unused_stack[udict->unused_stack_ptr] = index;
-                // try to return to initial condition...
-                if (index == udict->first_available_item-1) {
-                        udict->first_available_item--;
-                }
-                ret = 0;
-                // relink collisioned entry
-                if (udi->prev) {
-                        udict->items[udi->prev].next = udi->next;
-                }
-                if (udi->next) {
-                        udict->items[udi->next].prev = udi->prev;
-                }
-                if (!udi->prev && !udi->next) {
-                        // reset hashtable entry
-                        udict->hashtable[udi->djbhash % 0xffff] = 0;
-                }
-                udi->djbhash = 0;
-                udi->prev = 0;
-                udi->next = 0;
-        }
-
-        return ret;
-}
-
-
-
 inline uint64_t uwsgi_cache_get_index(char *key, uint16_t keylen) {
 
 	uint32_t hash = djb33x_hash(key, keylen);
@@ -512,7 +284,7 @@ int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint
 			uci->prev = last_index;
 		}
 	}
-	else if (flags && UWSGI_CACHE_FLAG_UPDATE) {
+	else if (flags & UWSGI_CACHE_FLAG_UPDATE) {
 		uci = &uwsgi.cache_items[index] ;
 		if (expires) {
 			expires += time(NULL);
@@ -528,71 +300,6 @@ end:
 	
 }
 
-int uwsgi_dict_set(struct uwsgi_dict *udict, char *key, uint16_t keylen, char *val, uint64_t vallen) {
-
-        uint64_t index = 0, last_index = 0 ;
-
-        struct uwsgi_dict_item *udi, *udii;
-
-        int ret = -1;
-        int slot;
-
-        if (!keylen || !vallen) return -1;
-
-        if (keylen > UWSGI_CACHE_MAX_KEY_SIZE) return -1;
-
-        if (udict->first_available_item >= udict->max_items && !udict->unused_stack_ptr) {
-                uwsgi_log("*** DANGER dictionary %p is FULL !!! ***\n", udict);
-                goto end;
-        }
-
-        index = uwsgi_dict_get_index(udict, key, keylen);
-        if (!index) {
-                if (udict->unused_stack_ptr) {
-                        index = udict->unused_stack[udict->unused_stack_ptr];
-                        udict->unused_stack_ptr--;
-                }
-                else {
-                        index = udict->first_available_item;
-                        if (udict->first_available_item < udict->max_items) {
-                                udict->first_available_item++;
-                        }
-                }
-                udi = &udict->items[index] ;
-                udi->djbhash = djb33x_hash(key, keylen);
-                udi->hits = 0;
-                memcpy(udi->key, key, keylen);
-                memcpy(udict->data+(index*udict->blocksize), val, vallen);
-
-                // set this as late as possibile (to reduce races risk)
-
-                udi->valsize = vallen;
-                udi->keysize = keylen;
-                ret = 0;
-                // now put the value in the 16bit hashtable
-                slot = udi->djbhash % 0xffff;
-
-                if (udict->hashtable[slot] == 0) {
-                        udict->hashtable[slot] = index;
-                }
-                else {
-                        // append to first available next
-                        last_index = udict->hashtable[slot];
-                        udii = &udict->items[ last_index ];
-                        while(udii->next) {
-                                last_index = udii->next;
-                                udii = &udict->items[ last_index ];
-                        }
-                        udii->next = index;
-                        udi->prev = last_index;
-                }
-        }
-
-end:
-        return ret;
-
-}
-
 /* THIS PART IS HEAVILY OPTIMIZED: PERFORMANCE NOT ELEGANCE !!! */
 
 void *cache_thread_loop(void *fd_ptr) {

contrib/centos_init_script

@@ -0,0 +1,99 @@
+#!/bin/bash
+
+# uwsgi - Use uwsgi to run python and wsgi web apps.
+#
+# chkconfig: - 85 15
+# description: Use uwsgi to run python and wsgi web apps.
+# processname: uwsgi
+
+# author: Roman Vasilyev
+
+# Source function library.
+. /etc/rc.d/init.d/functions
+
+PATH=/opt/uwsgi:/sbin:/bin:/usr/sbin:/usr/bin
+prog=/usr/sbin/uwsgi
+
+OWNER=nginx
+
+NAME=uwsgi
+DESC=uwsgi
+
+#DAEMON_OPTS="-s 127.0.0.1:9001 -M 4 -t 30 -A 4 -p 4 -d /var/log/uwsgi.log --pidfile /var/run/$NAME.pid --pythonpath $PYTHONPATH --module $MODULE"
+DAEMON_OPTS="-s 127.0.0.1:9001 -M 4 -t 30 -A 4 -p 16 -b 32768 -d /var/log/$NAME.log --pidfile /var/run/$NAME.pid --uid $OWNER"
+
+[ -f /etc/sysconfig/uwsgi ] && . /etc/sysconfig/uwsgi
+
+lockfile=/var/lock/subsys/uwsgi
+
+start () {
+  echo -n "Starting $DESC: "
+  daemon $prog $DAEMON_OPTS
+  retval=$?
+  echo
+  [ $retval -eq 0 ] && touch $lockfile
+  return $retval
+}
+
+stop () {
+  echo -n "Stopping $DESC: "
+  killproc $prog
+  retval=$?
+  echo
+  [ $retval -eq 0 ] && rm -f $lockfile
+  return $retval
+}
+
+reload () {
+  echo "Reloading $NAME" 
+  killproc $prog -HUP
+  RETVAL=$?
+  echo
+}
+
+force-reload () {
+  echo "Reloading $NAME" 
+  killproc $prog -TERM
+  RETVAL=$?
+  echo
+}
+
+restart () {
+    stop
+    start
+}
+
+rh_status () {
+  status $prog
+}
+
+rh_status_q() {
+  rh_status >/dev/null 2>&1
+}
+
+case "$1" in
+  start)
+    rh_status_q && exit 0
+    $1
+    ;;
+  stop)
+    rh_status_q || exit 0
+    $1
+    ;;
+  restart|force-reload)
+    $1
+    ;;
+  reload)
+    rh_status_q || exit 7
+    $1
+    ;;
+  status)
+    rh_status
+    ;;
+  *)  
+    echo "Usage: $0 {start|stop|restart|reload|force-reload|status}" >&2
+    exit 2
+    ;;
+  esac
+  exit 0
+

contrib/urack.rb

@@ -1,5 +1,9 @@
 require 'rubygems'
 require 'socket'
+begin
+        require 'bundler/setup'
+rescue LoadError
+end
 require 'rack'
 require 'rack/content_length'
 require 'rack/rewindable_input'

emperor.c

@@ -8,6 +8,8 @@ extern char **environ;
 int emperor_queue;
 char *emperor_absolute_dir;
 
+void emperor_send_stats(int);
+
 struct uwsgi_instance {
         struct uwsgi_instance *ui_prev;
         struct uwsgi_instance *ui_next;
@@ -177,7 +179,7 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size, ui
 	struct uwsgi_instance *c_ui = ui;
 	struct uwsgi_instance *n_ui = NULL;
 	pid_t pid;
-	char **argv;
+	char **vassal_argv;
 	char *uef;
 	char **uenvs;
 	int counter;
@@ -338,9 +340,9 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size, ui
 			uct = uct->next;
 		}
 
-		argv = uwsgi_malloc(sizeof(char *) * counter);
+		vassal_argv = uwsgi_malloc(sizeof(char *) * counter);
 		// set args
-		argv[0] = uwsgi.binary_path;
+		vassal_argv[0] = uwsgi.binary_path;
 
 		if (uwsgi.emperor_broodlord) {
 			colon = strchr(name, ':');
@@ -349,29 +351,31 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size, ui
 			}
 		}
 		if (!strcmp(name + (strlen(name) - 4), ".xml"))
-			argv[1] = "--xml";
+			vassal_argv[1] = "--xml";
 		if (!strcmp(name + (strlen(name) - 4), ".ini"))
-			argv[1] = "--ini";
+			vassal_argv[1] = "--ini";
 		if (!strcmp(name + (strlen(name) - 4), ".yml"))
-			argv[1] = "--yaml";
+			vassal_argv[1] = "--yaml";
 		if (!strcmp(name + (strlen(name) - 5), ".yaml"))
-			argv[1] = "--yaml";
+			vassal_argv[1] = "--yaml";
 		if (!strcmp(name + (strlen(name) - 3), ".js"))
-			argv[1] = "--json";
+			vassal_argv[1] = "--json";
+		if (!strcmp(name + (strlen(name) - 5), ".json"))
+			vassal_argv[1] = "--json";
 
 		if (colon) {
 			colon[0] = ':';
 		}
-		argv[2] = name;
+		vassal_argv[2] = name;
 		counter = 3;
 		uct = uwsgi.vassals_templates;
         	while(uct) {
-			argv[counter] = "--inherit";
-			argv[counter+1] = uct->filename;
+			vassal_argv[counter] = "--inherit";
+			vassal_argv[counter+1] = uct->filename;
 			counter+=2;
 			uct = uct->next;
 		}
-		argv[counter] = NULL;
+		vassal_argv[counter] = NULL;
 
 		// close all of the unneded fd
 		for(i=3;i<sysconf(_SC_OPEN_MAX);i++) {
@@ -390,7 +394,7 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size, ui
 		}
 
 		// start !!!
-		if (execvp(argv[0], argv)) {
+		if (execvp(vassal_argv[0], vassal_argv)) {
 			uwsgi_error("execvp()");
 		}
 		uwsgi_log("is the uwsgi binary in your system PATH ?\n");
@@ -430,6 +434,8 @@ void emperor_loop() {
 	int interesting_fd;
 	char notification_message[64];
 
+	uwsgi.emperor_stats_fd = -1;
+
 	signal(SIGPIPE, SIG_IGN);
 	uwsgi_unix_signal(SIGINT, royal_death);
         uwsgi_unix_signal(SIGTERM, royal_death);
@@ -450,6 +456,23 @@ void emperor_loop() {
 		uwsgi_log("*** starting uWSGI Emperor ***\n");
 	}
 
+	if (uwsgi.emperor_stats) {
+                char *tcp_port = strchr(uwsgi.emperor_stats, ':');
+                if (tcp_port) {
+                        // disable deferred accept for this socket
+                        int current_defer_accept = uwsgi.no_defer_accept;
+                        uwsgi.no_defer_accept = 1;
+                        uwsgi.emperor_stats_fd = bind_to_tcp(uwsgi.emperor_stats, uwsgi.listen_queue, tcp_port);
+                        uwsgi.no_defer_accept = current_defer_accept;
+                }
+                else {
+                        uwsgi.emperor_stats_fd = bind_to_unix(uwsgi.emperor_stats, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+                }
+
+                event_queue_add_fd_read(emperor_queue, uwsgi.emperor_stats_fd);
+                uwsgi_log("*** Emperor stats server enabled on %s fd: %d ***\n", uwsgi.emperor_stats, uwsgi.emperor_stats_fd);
+        }
+
 	amqp_port = strchr(uwsgi.emperor_dir, ':');
 
 	if (amqp_port) {
@@ -591,6 +614,11 @@ reconnect:
 				}
 				}
 			}
+			else if (uwsgi.emperor_stats && uwsgi.emperor_stats_fd > -1) {
+                        	if (interesting_fd == uwsgi.emperor_stats_fd) {
+                                	emperor_send_stats(uwsgi.emperor_stats_fd);
+                                }
+                        }
 			else {
 				ui_current = emperor_get_by_fd(interesting_fd);
 				if (ui_current) {
@@ -634,7 +662,8 @@ reconnect:
 					!strcmp(de->d_name + (strlen(de->d_name) - 4), ".ini") ||
 					!strcmp(de->d_name + (strlen(de->d_name) - 4), ".yml") ||
 					!strcmp(de->d_name + (strlen(de->d_name) - 5), ".yaml") ||
-					!strcmp(de->d_name + (strlen(de->d_name) - 3), ".js")
+					!strcmp(de->d_name + (strlen(de->d_name) - 3), ".js") ||
+					!strcmp(de->d_name + (strlen(de->d_name) - 5), ".json")
 					) {
 
 
@@ -681,6 +710,7 @@ reconnect:
 					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 4), ".ini") ||
 					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 4), ".yml") ||
 					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 3), ".js") ||
+					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 5), ".json") ||
 					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 5), ".yaml")
 					) {
 
@@ -794,3 +824,72 @@ reconnect:
 	}
 
 }
+
+#define stats_send_llu(x, y) fprintf(output, x, (long long unsigned int) y)
+#define stats_send(x, y) fprintf(output, x, y)
+
+void emperor_send_stats(int fd) {
+
+        struct sockaddr_un client_src;
+        socklen_t client_src_len = 0;
+        int client_fd = accept(fd, (struct sockaddr *) &client_src, &client_src_len);
+        if (client_fd < 0) {
+                uwsgi_error("accept()");
+                return;
+        }
+
+        FILE *output = fdopen(client_fd, "w");
+        if (!output) {
+                uwsgi_error("fdopen()");
+                close(client_fd);
+                return;
+        }
+
+        stats_send("{ \"version\": \"%s\",\n", UWSGI_VERSION);
+
+        fprintf(output,"\"uid\": %d,\n", (int)(getuid()));
+        fprintf(output,"\"gid\": %d,\n", (int)(getgid()));
+
+	char *cwd = uwsgi_get_cwd();
+        stats_send("\"cwd\": \"%s\",\n", cwd);
+        free(cwd);
+
+	stats_send("\"emperor\": \"%s\",\n", uwsgi.emperor_dir);
+
+        fprintf(output,"\"emperor_tyrant\": %d,\n", uwsgi.emperor_tyrant);
+
+
+        fprintf(output, "\"vassals\": [\n");
+
+	struct uwsgi_instance *c_ui = ui->ui_next;
+
+        while (c_ui) {
+                fprintf(output,"\t{");
+                stats_send("\"id\": \"%s\", ", c_ui->name);
+                fprintf(output,"\"pid\": %d, ", (int) c_ui->pid);
+
+		stats_send_llu( "\"born\": %llu, ", c_ui->born);
+		stats_send_llu( "\"last_mod\": %llu, ", c_ui->last_mod);
+
+                fprintf(output,"\"loyal\": %d, ", c_ui->loyal);
+                fprintf(output,"\"zerg\": %d, ", c_ui->zerg);
+
+                fprintf(output,"\"uid\": %d, ", (int)c_ui->uid);
+                fprintf(output,"\"gid\": %d, ", (int)c_ui->gid);
+
+		stats_send_llu( "\"respawns\": %llu ", c_ui->respawns);
+        	c_ui = c_ui->ui_next;
+
+		if (c_ui) {
+                	fprintf(output,"},\n");
+                }
+                else {
+                	fprintf(output,"}\n");
+                }
+        }
+
+
+	fprintf(output,"]}\n");
+        fclose(output);
+
+}

event.c

@@ -81,7 +81,7 @@ void *event_queue_alloc(int nevents) {
 int event_queue_interesting_fd(void *events, int id) {
 	port_event_t *pe = (port_event_t *) events;
 	if (pe[id].portev_source == PORT_SOURCE_FILE || pe[id].portev_source == PORT_SOURCE_TIMER) {
-                return (int) pe[id].portev_user;
+                return (long) pe[id].portev_user;
         }
 
 	return (int) pe[id].portev_object;
@@ -149,7 +149,7 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 
 
 	if (pe.portev_source == PORT_SOURCE_FILE || pe.portev_source == PORT_SOURCE_TIMER) {
-        	*interesting_fd = (int) pe.portev_user;
+        	*interesting_fd = (long) pe.portev_user;
 	}
 	else {
 		*interesting_fd = (int) pe.portev_object;
@@ -327,11 +327,13 @@ int event_queue_fd_write_to_read(int eq, int fd) {
 
 	struct kevent kev;
 
+#ifndef __FreeBSD__
         EV_SET(&kev, fd, EVFILT_WRITE, EV_DISABLE, 0, 0, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
                 uwsgi_error("kevent()");
                 return -1;
         }
+#endif
 
         EV_SET(&kev, fd, EVFILT_READ, EV_ADD, 0, 0, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
@@ -476,7 +478,7 @@ int event_queue_add_file_monitor(int eq, char *filename, int *id) {
 	fo.fo_ctime = st.st_ctim;
 	
 	fmon_id++;
-	if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *) fmon_id)) {
+	if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *) (long) fmon_id)) {
 		uwsgi_error("port_associate()");
 		return -1;
 	}
@@ -506,7 +508,7 @@ struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
         			fo.fo_atime = st.st_atim;
         			fo.fo_mtime = st.st_mtim;
         			fo.fo_ctime = st.st_ctim;
-				if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *)id)) {
+				if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *)(long)id)) {
                 			uwsgi_error("port_associate()");
                 			return NULL;
         			}
@@ -691,6 +693,8 @@ static int timerfd_create (clockid_t __clock_id, int __flags) {
 	return syscall(283, __clock_id, __flags);
 #elif defined(__i386__)
 	return syscall(322, __clock_id, __flags);
+#else
+	return -1;
 #endif
 }
 
@@ -773,7 +777,7 @@ int event_queue_add_timer(int eq, int *id, int sec) {
 	timer_id++;
 
 	pnotif.portnfy_port = eq;
-	pnotif.portnfy_user = (void *) timer_id;
+	pnotif.portnfy_user = (void *) (long) timer_id;
 
 	sigev.sigev_notify = SIGEV_PORT;
 	sigev.sigev_value.sival_ptr = &pnotif;

fdconf.pl

@@ -0,0 +1,7 @@
+use POSIX;
+
+open CONFIG,'welcome.ini';
+
+dup2(fileno(CONFIG), 17);
+
+exec './uwsgi','--ini','fd://17';

gateway.c

@@ -47,7 +47,7 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop)(void)) {
 		}
 	}
 
-	gw_pid = fork();
+	gw_pid = uwsgi_fork(name);
 	if (gw_pid < 0) {
 		uwsgi_error("fork()");
 		return NULL;
@@ -90,7 +90,7 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop)(void)) {
 	ug->loop = loop;
 	ug->num = num;
 
-	uwsgi_log( "spawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) ug->pid);
+	uwsgi_log( "spawned %s %d (pid: %d)\n", ug->name, ug->num, (int) ug->pid);
 
 	uwsgi.gateways_cnt++;
 
@@ -103,7 +103,7 @@ void gateway_respawn(int id) {
 	pid_t gw_pid;
 	struct uwsgi_gateway *ug = &uwsgi.gateways[id];
 	
-	gw_pid = fork();
+	gw_pid = uwsgi_fork(ug->name);
 	if (gw_pid < 0) {
                 uwsgi_error("fork()");
 		return;
@@ -124,10 +124,10 @@ void gateway_respawn(int id) {
 	ug->pid = gw_pid;
 	ug->respawns++;
 	if (ug->respawns == 1) {
-		uwsgi_log( "spawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+		uwsgi_log( "spawned %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
 	}
 	else {
-		uwsgi_log( "respawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+		uwsgi_log( "respawned %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
 	}
 	
 }

ini.c

@@ -92,7 +92,7 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 	char *section_asked = "uwsgi";
 	char *colon;
 
-	if (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) ) {
+	if (uwsgi_check_scheme(file)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }

json.c

@@ -30,7 +30,7 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 	char *colon;
 	int i;
 
-	if (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6)) {
+	if (uwsgi_check_scheme(file)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }
@@ -77,10 +77,10 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 			add_exported_option((char *)key, (char *) json_string_value(config_value), 0);
 		}
 		else if (json_is_true(config_value)) {
-			add_exported_option((char *)key, (char *) "1", 0);
+			add_exported_option((char *)key, strdup("1"), 0);
 		}
 		else if (json_is_false(config_value) || json_is_null(config_value)) {
-			add_exported_option((char *)key, (char *) "0", 0);
+			add_exported_option((char *)key, strdup("0"), 0);
 		}
 		else if (json_is_integer(config_value)) {
 			add_exported_option((char *)key, uwsgi_num2str(json_integer_value(config_value)), 0);
@@ -92,10 +92,10 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
                         		add_exported_option((char *)key, (char *) json_string_value(config_array_item), 0);
                 		}
                 		else if (json_is_true(config_array_item)) {
-                        		add_exported_option((char *)key, (char *) "1", 0);
+                        		add_exported_option((char *)key, strdup("1"), 0);
                 		}
                 		else if (json_is_false(config_array_item) || json_is_null(config_array_item)) {
-                        		add_exported_option((char *)key, (char *) "0", 0);
+                        		add_exported_option((char *)key, strdup("0"), 0);
                 		}
                 		else if (json_is_integer(config_array_item)) {
                         		add_exported_option((char *)key, uwsgi_num2str(json_integer_value(config_array_item)), 0);

lib/rbtree.c

@@ -19,7 +19,7 @@
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 
 */
 

lib/rbtree.h

@@ -18,7 +18,7 @@
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 
 */
 

logging.c

@@ -129,22 +129,22 @@ void log_request(struct wsgi_request *wsgi_req) {
 	rlen = writev(2, logvec, logvecpos+1);
 }
 
-void get_memusage() {
+void get_memusage(uint64_t *rss, uint64_t *vsz) {
 
 #ifdef UNBIT
-	uwsgi.workers[uwsgi.mywid].vsz_size = syscall(356);
+	*vsz = syscall(356);
 #elif defined(__linux__)
 	FILE *procfile;
 	int i;
 	procfile = fopen("/proc/self/stat", "r");
 	if (procfile) {
-		i = fscanf(procfile, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %llu %lld", (unsigned long long *) &uwsgi.workers[uwsgi.mywid].vsz_size, (unsigned long long *) &uwsgi.workers[uwsgi.mywid].rss_size);
+		i = fscanf(procfile, "%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %llu %lld", (unsigned long long *) vsz, (unsigned long long *) rss);
 		if (i != 2) {
 			uwsgi_log( "warning: invalid record in /proc/self/stat\n");
 		}
 		fclose(procfile);
 	}
-	uwsgi.workers[uwsgi.mywid].rss_size = uwsgi.workers[uwsgi.mywid].rss_size * uwsgi.page_size;
+	*rss = *rss * uwsgi.page_size;
 #elif defined (__sun__)
 	psinfo_t info;
 	int procfd;
@@ -152,8 +152,8 @@ void get_memusage() {
 	procfd = open("/proc/self/psinfo", O_RDONLY);
 	if (procfd >= 0) {
 		if ( read(procfd, (char *) &info, sizeof(info)) > 0) {
-			uwsgi.workers[uwsgi.mywid].rss_size = (uint64_t) info.pr_rssize * 1024;
-			uwsgi.workers[uwsgi.mywid].vsz_size = (uint64_t) info.pr_size * 1024;
+			*rss = (uint64_t) info.pr_rssize * 1024;
+			*vsz = (uint64_t) info.pr_size * 1024;
 		}
 		close(procfd);
 	}
@@ -164,8 +164,8 @@ void get_memusage() {
 	mach_msg_type_number_t t_size = sizeof(struct task_basic_info);
 
 	if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t) & t_info, &t_size) == KERN_SUCCESS) {
-		uwsgi.workers[uwsgi.mywid].rss_size = t_info.resident_size;
-		uwsgi.workers[uwsgi.mywid].vsz_size = t_info.virtual_size;
+		*rss = t_info.resident_size;
+		*vsz = t_info.virtual_size;
 	}
 #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
 	kvm_t *kv;
@@ -184,8 +184,8 @@ void get_memusage() {
 		struct kinfo_proc *kproc;
 		kproc = kvm_getprocs(kv, KERN_PROC_PID, uwsgi.mypid, &cnt);
 		if (kproc && cnt > 0) {
-			uwsgi.workers[uwsgi.mywid].vsz_size = kproc->ki_size;
-			uwsgi.workers[uwsgi.mywid].rss_size = kproc->ki_rssize * uwsgi.page_size;
+			*vsz = kproc->ki_size;
+			*rss = kproc->ki_rssize * uwsgi.page_size;
 		}
 #elif defined(__NetBSD__) || defined(__OpenBSD__)
 		struct kinfo_proc2 *kproc2;
@@ -193,11 +193,11 @@ void get_memusage() {
 		kproc2 = kvm_getproc2(kv, KERN_PROC_PID, uwsgi.mypid, sizeof(struct kinfo_proc2), &cnt);
 		if (kproc2 && cnt > 0) {
 #ifdef __OpenBSD__
-			uwsgi.workers[uwsgi.mywid].vsz_size = (kproc2->p_vm_dsize + kproc2->p_vm_ssize + kproc2->p_vm_tsize) * uwsgi.page_size;
+			*vsz = (kproc2->p_vm_dsize + kproc2->p_vm_ssize + kproc2->p_vm_tsize) * uwsgi.page_size;
 #else
-			uwsgi.workers[uwsgi.mywid].vsz_size = kproc2->p_vm_msize * uwsgi.page_size;
+			*vsz = kproc2->p_vm_msize * uwsgi.page_size;
 #endif
-			uwsgi.workers[uwsgi.mywid].rss_size = kproc2->p_vm_rssize * uwsgi.page_size;
+			*rss = kproc2->p_vm_rssize * uwsgi.page_size;
 		}
 #endif
 
@@ -207,13 +207,14 @@ void get_memusage() {
 	area_info ai;
 	int32 cookie;
 
-	uwsgi.workers[uwsgi.mywid].vsz_size = 0;
-	uwsgi.workers[uwsgi.mywid].rss_size = 0;
+	*vsz = 0;
+	*rss = 0;
 	while(get_next_area_info(0, &cookie, &ai) == B_OK) {
-		uwsgi.workers[uwsgi.mywid].vsz_size += ai.ram_size;
+		*vsz += ai.ram_size;
 		if ( (ai.protection & B_WRITE_AREA) != 0) {
-			uwsgi.workers[uwsgi.mywid].rss_size += ai.ram_size;
+			*rss += ai.ram_size;
 		}
 	}
 #endif
+
 }

master.c

@@ -238,7 +238,7 @@ void manage_cluster_announce(char *key, uint16_t keylen, char *val, uint16_t val
 	}
 }
 
-void master_loop(char **argv, char **environ) {
+int master_loop(char **argv, char **environ) {
 
 	uint64_t tmp_counter;
 
@@ -284,15 +284,28 @@ void master_loop(char **argv, char **environ) {
 #ifdef UWSGI_SNMP
 	int snmp_fd = -1;
 #endif
-
 	int i=0;
 	int rlen;
 
 	int check_interval = 1;
+	uint64_t overload_count = 0;
+	uint64_t idle_count = 0;
 
 	struct uwsgi_rb_timer *min_timeout;
 	struct rb_root *rb_timers = uwsgi_init_rb_timer();
 
+
+	if (uwsgi.procname_master) {
+		uwsgi_set_processname(uwsgi.procname_master);
+	}
+	else if (uwsgi.procname) {
+		uwsgi_set_processname(uwsgi.procname);
+	}
+	else if (uwsgi.auto_procname) {
+		uwsgi_set_processname("uWSGI master");
+	}
+
+
 	uwsgi.current_time = time(NULL);
 
 	uwsgi_unix_signal(SIGHUP, grace_them_all);
@@ -346,6 +359,23 @@ void master_loop(char **argv, char **environ) {
 		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.zerg_server_fd);
 		uwsgi_log("*** Zerg server enabled on %s ***\n", uwsgi.zerg_server);
 	}
+
+	if (uwsgi.stats) {
+		char *tcp_port = strchr(uwsgi.stats, ':');
+                if (tcp_port) {
+			// disable deferred accept for this socket
+			int current_defer_accept = uwsgi.no_defer_accept;
+			uwsgi.no_defer_accept = 1;
+                	uwsgi.stats_fd = bind_to_tcp(uwsgi.stats, uwsgi.listen_queue, tcp_port);
+			uwsgi.no_defer_accept = current_defer_accept;
+                }
+                else {
+                	uwsgi.stats_fd = bind_to_unix(uwsgi.stats, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+                }
+		
+		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.stats_fd);
+		uwsgi_log("*** Stats server enabled on %s fd: %d ***\n", uwsgi.stats, uwsgi.stats_fd);
+	}
 #ifdef UWSGI_UDP
 	if (uwsgi.udp_socket) {
 		udp_fd = bind_to_udp(uwsgi.udp_socket, 0, 0);
@@ -360,6 +390,9 @@ void master_loop(char **argv, char **environ) {
 
 	if (uwsgi.cheap) {
 		uwsgi_add_sockets_to_queue(uwsgi.master_queue);
+		for(i=1;i<=uwsgi.numproc;i++) {
+			uwsgi.workers[i].cheaped = 1;
+		}
 		uwsgi_log("cheap mode enabled: waiting for socket connection...\n");
 	}
 
@@ -459,10 +492,12 @@ void master_loop(char **argv, char **environ) {
 #endif
 
 	
-/*
-
-
-*/
+	// spawn mules
+	for(i=0;i<uwsgi.mules_cnt;i++) {
+		size_t mule_patch_size = 0;
+		uwsgi.mules[i].patch = uwsgi_string_get_list(&uwsgi.mules_patches, i, &mule_patch_size);
+		uwsgi_mule(i+1);
+	}
 
 	// spawn fat gateways
 	for(i=0;i<uwsgi.gateways_cnt;i++) {
@@ -472,9 +507,10 @@ void master_loop(char **argv, char **environ) {
         }
 
 	// first subscription
-	for(i=0;i<uwsgi.subscriptions_cnt;i++) {
-		uwsgi_log("requested subscription for %s\n", uwsgi.subscriptions[i]);
-		uwsgi_subscribe(uwsgi.subscriptions[i]);
+	struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
+	while(subscriptions) {
+		uwsgi_subscribe(subscriptions->value);
+		subscriptions = subscriptions->next;
 	}
 
 	// sync the cache store if needed
@@ -490,21 +526,34 @@ void master_loop(char **argv, char **environ) {
 		}
 	}
 
-	if (uwsgi.touch_reload) {
+	struct uwsgi_string_list *touch_reload = uwsgi.touch_reload;
+	while(touch_reload) {
 		struct stat tr_st;
-		if (stat(uwsgi.touch_reload, &tr_st)) {
-			uwsgi_error("stat()");
-			uwsgi_log("unable to stat() %s, touch-reload will be disabled\n", uwsgi.touch_reload);
-			uwsgi.touch_reload = NULL;
+		if (stat(touch_reload->value, &tr_st)) {
+			uwsgi_log("unable to stat() %s, reload will be triggered as soon as the file is created\n", touch_reload->value);
+			touch_reload->custom = 0;
 		}
 		else {
-			uwsgi.last_touch_reload_mtime = tr_st.st_mtime;
+			touch_reload->custom = (uint64_t) tr_st.st_mtime;
 		}
+		touch_reload = touch_reload->next;
+		
 	}
 
 	for (;;) {
 		//uwsgi_log("ready_to_reload %d %d\n", ready_to_reload, uwsgi.numproc);
 
+		for (i = 0; i < uwsgi.gp_cnt; i++) {
+                	if (uwsgi.gp[i]->master_cycle) {
+                        	uwsgi.gp[i]->master_cycle();
+			}
+		}
+                for (i = 0; i < 0xFF; i++) {
+                	if (uwsgi.p[i]->master_cycle) {
+				uwsgi.p[i]->master_cycle();
+			}
+		}
+
 		if (uwsgi.to_outworld) {
 			//uwsgi_log("%d/%d\n", uwsgi.lazy_respawned, uwsgi.numproc);
 			if (uwsgi.lazy_respawned >= uwsgi.numproc) {
@@ -513,6 +562,7 @@ void master_loop(char **argv, char **environ) {
 				uwsgi.lazy_respawned = 0;
 			}
 		}
+
 		if (uwsgi.master_mercy) {
 			if (uwsgi.master_mercy < time(NULL)) {
 				for(i=1;i<=uwsgi.numproc;i++) {
@@ -528,7 +578,7 @@ void master_loop(char **argv, char **environ) {
 							else if (uwsgi.to_heaven) { ready_to_reload++;}
 							else if (uwsgi.to_outworld) {
 								uwsgi.lazy_respawned++;
-								if (uwsgi_respawn_worker(i)) return;	
+								if (uwsgi_respawn_worker(i)) return 0;	
 							}
 						}
 						else {
@@ -541,7 +591,7 @@ void master_loop(char **argv, char **environ) {
 		}
 		if (uwsgi.respawn_workers) {
 			for(i=1;i<=uwsgi.numproc;i++) {
-				if (uwsgi_respawn_worker(i)) return;
+				if (uwsgi_respawn_worker(i)) return 0;
 			}
 
 			uwsgi.respawn_workers = 0;
@@ -569,9 +619,74 @@ void master_loop(char **argv, char **environ) {
 			uwsgi.restore_snapshot = 0;
 			continue;
 		}
+
+		// cheaper management
+		if (uwsgi.cheaper) {
+			for(i=1;i<=uwsgi.numproc;i++) {
+				if (uwsgi.workers[i].cheaped == 0 && uwsgi.workers[i].pid > 0) {
+					if (uwsgi.workers[i].busy == 0) {
+						if (overload_count > 0) overload_count--;
+						goto healthy;
+					}		
+				}
+			}
+			overload_count++;
+			idle_count = 0;
+		}
+
+healthy:
+		if (uwsgi.cheaper) {
+			if (overload_count > 3) {
+				// activate the first available worker
+				for(i=1;i<=uwsgi.numproc;i++) {
+					if (uwsgi.workers[i].cheaped == 1 && uwsgi.workers[i].pid == 0) {
+						if (uwsgi_respawn_worker(i)) return 0;
+						overload_count = 0;
+						break;
+					}
+				}
+			}
+			else if (overload_count == 0) {
+				// how many active workers ?
+				idle_count++;
+				int active_workers = 0;
+				for(i=1;i<=uwsgi.numproc;i++) {
+					if (uwsgi.workers[i].cheaped == 0 && uwsgi.workers[i].pid > 0) {
+						active_workers++;
+					}
+				}
+			
+				// find the oldest worker and cheap it
+				if (active_workers > uwsgi.cheaper_count+1 || (idle_count > 60 && active_workers > uwsgi.cheaper_count)) {
+					time_t oldest_worker_spawn = INT_MAX;
+					int oldest_worker = 0;
+					idle_count = 0;
+					for(i=1;i<=uwsgi.numproc;i++) {
+						if (uwsgi.workers[i].cheaped == 0 && uwsgi.workers[i].pid > 0) {
+							if (uwsgi.workers[i].last_spawn < oldest_worker_spawn) {
+								oldest_worker_spawn = uwsgi.workers[i].last_spawn;
+								oldest_worker = i;
+							}		
+						}
+					}	
+					if (oldest_worker > 0) {
+#ifdef UWSGI_DEBUG
+						uwsgi_log("worker %d should die...\n", oldest_worker);
+#endif
+						uwsgi.workers[oldest_worker].cheaped = 1;
+						uwsgi.workers[oldest_worker].manage_next_request = 0;
+						// wakeup task in case of wait
+						(void) kill(uwsgi.workers[oldest_worker].pid, SIGWINCH);
+						overload_count = 0;
+					}
+				}
+			}
+		}
+
+
 		if ((uwsgi.cheap || ready_to_die >= uwsgi.numproc) && uwsgi.to_hell) {
-			// call a series of waitpid to ensure all processes (gateways and daemons) are dead
-			for(i=0;i<(uwsgi.gateways_cnt+ushared->daemons_cnt);i++) {
+			// 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++) {
 				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			}
 
@@ -579,8 +694,8 @@ void master_loop(char **argv, char **environ) {
 			exit(0);
 		}
 		if ( (uwsgi.cheap || ready_to_reload >= uwsgi.numproc) && uwsgi.to_heaven) {
-			// call a series of waitpid to ensure all processes (gateways and daemons) are dead
-			for(i=0;i<(uwsgi.gateways_cnt+ushared->daemons_cnt);i++) {
+			// 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++) {
 				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			}
 
@@ -599,6 +714,7 @@ void master_loop(char **argv, char **environ) {
 			uwsgi_log( "closing all non-uwsgi socket fds > 2 (_SC_OPEN_MAX = %ld)...\n", sysconf(_SC_OPEN_MAX));
 			for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
 				int found = 0;
+
 				struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
                 		while(uwsgi_sock) {
 					if (i == uwsgi_sock->fd) {
@@ -616,6 +732,13 @@ void master_loop(char **argv, char **environ) {
 						}
 					}
 				}
+
+				if (uwsgi.original_log_fd > -1) {
+					if (i == uwsgi.original_log_fd) {
+						dup2(uwsgi.original_log_fd, 1);
+						dup2(1, 2);
+					}
+				}
 				if (!found) {
 #ifdef __APPLE__
 					fcntl(i, F_SETFD, FD_CLOEXEC);	
@@ -625,6 +748,9 @@ void master_loop(char **argv, char **environ) {
 				}
 			}
 
+#ifdef UWSGI_AS_SHARED_LIBRARY
+			return -1;
+#else
 			uwsgi_log( "running %s\n", uwsgi.binary_path);
 			argv[0] = uwsgi.binary_path;
 			//strcpy (argv[0], uwsgi.binary_path);
@@ -632,6 +758,7 @@ void master_loop(char **argv, char **environ) {
 			uwsgi_error("execvp()");
 			// never here
 			exit(1);
+#endif
 		}
 
 		if (!uwsgi.cheap) {
@@ -652,6 +779,16 @@ void master_loop(char **argv, char **environ) {
 		else {
 			diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			if (diedpid == -1) {
+				if (errno == ECHILD && uwsgi.cheaper) {
+					if (uwsgi.to_heaven) {
+                                		ready_to_reload = uwsgi.numproc;
+						continue;
+					}
+                        		else if (uwsgi.to_hell) {
+						ready_to_die = uwsgi.numproc;
+						continue;
+					}
+				}
 				uwsgi_error("waitpid()");
 				/* here is better to reload all the uWSGI stack */
 				uwsgi_log( "something horrible happened...\n");
@@ -769,6 +906,12 @@ void master_loop(char **argv, char **environ) {
 						}
 					}
 
+					if (uwsgi.stats && uwsgi.stats_fd > -1) {
+						if (interesting_fd == uwsgi.stats_fd) {
+							uwsgi_send_stats(uwsgi.stats_fd);
+						}
+					}
+
 					if (uwsgi.zerg_server) {
 						if (interesting_fd == uwsgi.zerg_server_fd) {
 							struct sockaddr_un zsun;
@@ -855,7 +998,7 @@ void master_loop(char **argv, char **environ) {
 								uwsgi.cheap = 0;
 								uwsgi_del_sockets_from_queue(uwsgi.master_queue);
 								for(i=1;i<=uwsgi.numproc;i++) {
-									if (uwsgi_respawn_worker(i)) return;		
+									if (uwsgi_respawn_worker(i)) return 0;		
 								}
 								break;
 							}
@@ -1054,18 +1197,46 @@ void master_loop(char **argv, char **environ) {
 			uwsgi.current_time = time(NULL);	
 			// checking logsize
 			if (uwsgi.logfile) {
-				uwsgi.shared->logsize = lseek(2, 0, SEEK_CUR);
-/*
-				if (uwsgi.shared->logsize > 8192) {
-					//uwsgi_log("logsize: %d\n", uwsgi.shared->logsize);
-					char *new_logfile = uwsgi_malloc(strlen(uwsgi.logfile) + 14 + 1);
-					memset(new_logfile, 0, strlen(uwsgi.logfile) + 14 + 1);    
-					if (!rename(uwsgi.logfile, new_logfile)) {
-						// close 2, reopen logfile dup'it and gracefully reload workers;
+				if (uwsgi.log_master) {
+					uwsgi.shared->logsize = lseek(uwsgi.original_log_fd, 0, SEEK_CUR);
+				}
+				else {
+					uwsgi.shared->logsize = lseek(2, 0, SEEK_CUR);
+				}
+				if (uwsgi.log_maxsize > 0 && uwsgi.shared->logsize > uwsgi.log_maxsize) {
+					char *rot_name = uwsgi.log_backupname;
+					int need_free = 0;
+					if (rot_name == NULL) {
+						char *ts_str = uwsgi_num2str((int)time(NULL));
+						rot_name = uwsgi_concat3(uwsgi.logfile, ".", ts_str);
+						free(ts_str);
+						need_free = 1;
 					}
-					free(new_logfile);
+					char message[1024];
+					int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering rotation to %s...\n", (int) time(NULL), (unsigned long long) uwsgi.shared->logsize, rot_name);
+					if (ret > 0) {
+						rlen = write(uwsgi.original_log_fd, message, ret);
+						
+					}
+					if (rename(uwsgi.logfile, rot_name) == 0) {
+						// close 2, reopen logfile dup'it and gracefully reload workers;
+						int fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_TRUNC , S_IRUSR | S_IWUSR | S_IRGRP);
+						if (fd < 0) {
+                        				uwsgi_error_open(uwsgi.logfile);
+							grace_them_all(0);
+                				}
+						if (dup2(fd, uwsgi.original_log_fd) < 0) {
+							uwsgi_error("dup2()");
+							grace_them_all(0);
+						}
+
+					}
+					else {
+						uwsgi_error("unable to rotate log: rename()");
+					}
+					if (need_free)
+						free(rot_name);
 				}	
-*/
 			}
 
 				
@@ -1197,10 +1368,43 @@ void master_loop(char **argv, char **environ) {
 						uwsgi.workers[i].harakiri = 0;
 					}
 				}
+				// then for evil memory checkers
+				if (uwsgi.evil_reload_on_as) {
+					if ((rlim_t) uwsgi.workers[i].vsz_size >= uwsgi.evil_reload_on_as) {
+						uwsgi_log("*** EVIL RELOAD ON WORKER %d ADDRESS SPACE: %lld (pid: %d) ***\n", i, (long long) uwsgi.workers[i].vsz_size, uwsgi.workers[i].pid );
+						kill(uwsgi.workers[i].pid, SIGKILL);
+						uwsgi.workers[i].vsz_size = 0;
+					}
+				}
+				if (uwsgi.evil_reload_on_rss) {
+					if ((rlim_t) uwsgi.workers[i].rss_size >= uwsgi.evil_reload_on_rss) {
+						uwsgi_log("*** EVIL RELOAD ON WORKER %d RSS: %lld (pid: %d) ***\n", i, (long long) uwsgi.workers[i].rss_size, uwsgi.workers[i].pid );
+						kill(uwsgi.workers[i].pid, SIGKILL);
+						uwsgi.workers[i].rss_size = 0;
+					}
+				}
 
 				// need to find a better way
 				//uwsgi.workers[i].last_running_time = uwsgi.workers[i].running_time;
 			}
+			for (i = 0; i < uwsgi.mules_cnt; i++) {
+				if (uwsgi.mules[i].harakiri > 0) {
+					if (uwsgi.mules[i].harakiri < (time_t) uwsgi.current_time) {
+						uwsgi_log("*** HARAKIRI ON MULE %d HANDLING SIGNAL %d (pid: %d) ***\n", i+1, uwsgi.mules[i].signum, uwsgi.mules[i].pid );
+						kill(uwsgi.mules[i].pid, SIGKILL);
+						uwsgi.mules[i].harakiri = 0;
+					}
+				}
+			}
+#ifdef UWSGI_SPOOLER
+			if (uwsgi.shared->spooler_pid > 0 && uwsgi.shared->spooler_harakiri > 0) {
+				if (uwsgi.shared->spooler_harakiri < (time_t) uwsgi.current_time) {
+					uwsgi_log("*** HARAKIRI ON THE SPOOLER (pid: %d) ***\n", uwsgi.shared->spooler_pid);
+					kill(uwsgi.shared->spooler_pid, SIGKILL);
+					uwsgi.shared->spooler_harakiri = 0;
+				}
+			}
+#endif
 
 #ifdef UWSGI_UDP
 			// check for cluster nodes
@@ -1212,9 +1416,11 @@ void master_loop(char **argv, char **environ) {
 			}
 
 			// resubscribe every 10 cycles
-			if (uwsgi.subscriptions_cnt > 0 && ((uwsgi.master_cycles % 10) == 0 || uwsgi.master_cycles == 1)) {
-				for(i=0;i<uwsgi.subscriptions_cnt;i++) {
-					uwsgi_subscribe(uwsgi.subscriptions[i]);
+			if (uwsgi.subscriptions && ((uwsgi.master_cycles % 10) == 0 || uwsgi.master_cycles == 1)) {
+				struct uwsgi_string_list *subscriptions = uwsgi.subscriptions;
+				while(subscriptions) {
+					uwsgi_subscribe(subscriptions->value);
+					subscriptions = subscriptions->next;
 				}
 			}
 
@@ -1233,19 +1439,20 @@ void master_loop(char **argv, char **environ) {
 			}
 
 			// check touch_reload
-			if (uwsgi.touch_reload && !uwsgi.to_heaven && !uwsgi.to_hell) {
+			struct uwsgi_string_list *touch_reload = uwsgi.touch_reload;
+			while (touch_reload && !uwsgi.to_heaven && !uwsgi.to_hell) {
                 		struct stat tr_st;
-                		if (stat(uwsgi.touch_reload, &tr_st)) {
-                        		uwsgi_error("stat()");
-                        		uwsgi_log("unable to stat() %s, touch-reload will be disabled\n", uwsgi.touch_reload);
-                        		uwsgi.touch_reload = NULL;
+                		if (stat(touch_reload->value, &tr_st)) {
+					touch_reload->custom = 0;
                 		}
                 		else {
-					if (tr_st.st_mtime > uwsgi.last_touch_reload_mtime) {
-						uwsgi_log("*** %s has been touched... grace them all !!! ***\n", uwsgi.touch_reload);
+					if ((uint64_t)tr_st.st_mtime > touch_reload->custom) {
+						uwsgi_log("*** %s has been touched... grace them all !!! ***\n", touch_reload->value);
 						grace_them_all(0);
+						break;
 					}
                 		}
+				touch_reload = touch_reload->next;
 			}
 
 
@@ -1265,12 +1472,25 @@ void master_loop(char **argv, char **environ) {
 				uwsgi_log( "OOOPS the spooler is no more...trying respawn...\n");
 				uwsgi.spooler_respawned++;
 				uwsgi.shared->spooler_pid = spooler_start();
-				event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->spooler_signal_pipe[0]);
+				//event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->spooler_signal_pipe[0]);
 				continue;
 			}
 		}
 #endif
 
+		pid_found = 0;
+		for(i=0;i<uwsgi.mules_cnt;i++) {
+                        if (uwsgi.mules[i].pid == diedpid) {
+				uwsgi_log("OOOPS mule %d crippled...trying respawn...\n", i+1);
+                                uwsgi_mule(i+1);
+				pid_found = 1;
+				break;
+                        }
+                }
+
+		if (pid_found) continue;
+
+
 		/* reload the gateways */
 		// TODO reload_gateway(diedpid);
 		pid_found = 0;
@@ -1311,6 +1531,37 @@ void master_loop(char **argv, char **environ) {
 
 		uwsgi.mywid = find_worker_id(diedpid);
 		if (uwsgi.mywid <= 0) {
+			// check spooler, mules, gateways and daemons
+#ifdef UWSGI_SPOOLER
+			if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
+                        	if (diedpid == uwsgi.shared->spooler_pid) {	
+					uwsgi_log("spooler (pid: %d) annihilated\n", (int) diedpid);
+					goto next;	
+				}
+			}
+#endif
+
+			for(i=0;i<uwsgi.mules_cnt;i++) {
+				if (uwsgi.mules[i].pid == diedpid) {
+					uwsgi_log("mule %d (pid: %d) annihilated\n", i+1, (int) diedpid);
+					goto next;
+				}
+			}
+
+			for(i=0;i<uwsgi.gateways_cnt;i++) {
+				if (uwsgi.gateways[i].pid == diedpid) {
+					uwsgi_log("gateway %d (pid: %d) annihilated\n", i+1, (int) diedpid);
+					goto next;
+				}
+			}
+
+			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);
+					goto next;
+				}
+			}
+
 			if (WIFEXITED(waitpid_status)) {
 				uwsgi_log("subprocess %d exited with code %d\n", (int) diedpid, WEXITSTATUS(waitpid_status));
 			}
@@ -1320,10 +1571,12 @@ void master_loop(char **argv, char **environ) {
 			else if (WIFSTOPPED(waitpid_status)) {
 				uwsgi_log("subprocess %d stopped\n", (int) diedpid);
 			}
+next:
 			continue;
 		}
 		else {
 
+
 			if (uwsgi.to_heaven) {
                                 ready_to_reload++;
 				uwsgi.workers[uwsgi.mywid].pid = 0;
@@ -1350,6 +1603,12 @@ void master_loop(char **argv, char **environ) {
 		if (uwsgi.workers[uwsgi.mywid].manage_next_request) {
 			uwsgi_log( "DAMN ! worker %d (pid: %d) died :( trying respawn ...\n", uwsgi.mywid, (int)diedpid);
 		}
+
+		if (uwsgi.workers[uwsgi.mywid].cheaped == 1) {
+			uwsgi.workers[uwsgi.mywid].pid = 0;
+			uwsgi_log("uWSGI worker %d cheaped.\n", uwsgi.mywid);
+			continue;
+		}
 		gettimeofday(&last_respawn, NULL);
 		if (last_respawn.tv_sec == uwsgi.respawn_delta) {
 			last_respawn_rate++;
@@ -1373,7 +1632,7 @@ void master_loop(char **argv, char **environ) {
 			continue;
 		}
 		*/
-		if (uwsgi_respawn_worker(uwsgi.mywid)) return;
+		if (uwsgi_respawn_worker(uwsgi.mywid)) return 0;
 
 	}
 }

master_utils.c

@@ -2,6 +2,8 @@
 
 extern struct uwsgi_server uwsgi;
 
+void worker_wakeup() {}
+
 void master_check_cluster_nodes() {
 
 	int i;
@@ -31,71 +33,107 @@ void master_check_cluster_nodes() {
 	}
 }
 
+void uwsgi_fixup_fds(int wid, int muleid) {
+
+	int i;
+
+	// close the cache server
+	if (uwsgi.cache_server_fd != -1) {
+		close(uwsgi.cache_server_fd);
+	}
+
+	if (uwsgi.master_process) {
+                        // fix the communication pipe
+                        close(uwsgi.shared->worker_signal_pipe[0]);
+                        for(i=1;i<=uwsgi.numproc;i++) {
+                                if (uwsgi.workers[i].signal_pipe[0] != -1) close(uwsgi.workers[i].signal_pipe[0]);
+                                if (i != wid) {
+                                        if (uwsgi.workers[i].signal_pipe[1] != -1) close(uwsgi.workers[i].signal_pipe[1]);
+                                }
+                        }
+#ifdef UWSGI_SPOOLER
+			if (uwsgi.shared->spooler_pid != getpid()) {
+                        	if (uwsgi.shared->spooler_signal_pipe[0] != -1) close (uwsgi.shared->spooler_signal_pipe[0]);
+                        	if (uwsgi.shared->spooler_signal_pipe[1] != -1) close (uwsgi.shared->spooler_signal_pipe[1]);
+			}
+#endif
+
+                        if (uwsgi.shared->mule_signal_pipe[0] != -1) close(uwsgi.shared->mule_signal_pipe[0]);
+
+			if (muleid == 0) {
+                        	if (uwsgi.shared->mule_signal_pipe[1] != -1) close(uwsgi.shared->mule_signal_pipe[1]);
+                        	if (uwsgi.shared->mule_queue_pipe[1] != -1) close(uwsgi.shared->mule_queue_pipe[1]);
+			}
+
+                        for(i=0;i<uwsgi.mules_cnt;i++) {
+                                if (uwsgi.mules[i].signal_pipe[0] != -1) close(uwsgi.mules[i].signal_pipe[0]);
+				if (muleid != i+1) {
+                                	if (uwsgi.mules[i].signal_pipe[1] != -1) close(uwsgi.mules[i].signal_pipe[1]);
+                                	if (uwsgi.mules[i].queue_pipe[1] != -1) close(uwsgi.mules[i].queue_pipe[1]);
+				}
+                        }
+
+			for(i=0;i<uwsgi.farms_cnt;i++) {
+                                if (uwsgi.farms[i].signal_pipe[0] != -1) close(uwsgi.farms[i].signal_pipe[0]);
+
+				if (muleid == 0) {
+                                	if (uwsgi.farms[i].signal_pipe[1] != -1) close(uwsgi.farms[i].signal_pipe[1]);
+                                	if (uwsgi.farms[i].queue_pipe[1] != -1) close(uwsgi.farms[i].queue_pipe[1]);
+				}
+			}
+
+                }
+
+	
+}
 
 int uwsgi_respawn_worker(int wid) {
 
 	int respawns = uwsgi.workers[wid].respawn_count;
 	int i;
 
-	if (uwsgi.master_process) {
-		if (uwsgi.signal_pipe[wid][0] != -1) close(uwsgi.signal_pipe[wid][0]);
-
-		if (socketpair(AF_UNIX, SOCK_STREAM, 0, uwsgi.signal_pipe[wid])) {
-        		uwsgi_error("socketpair()\n");
-		}
-	}
-
-
-	pid_t pid = fork();
+	pid_t pid = uwsgi_fork(uwsgi.workers[wid].name);
 
 	if (pid == 0) {
+		signal(SIGWINCH, worker_wakeup);
 		uwsgi.mywid = wid;
 		uwsgi.mypid = getpid();
 		uwsgi.workers[uwsgi.mywid].pid = uwsgi.mypid;
 		uwsgi.workers[uwsgi.mywid].id = uwsgi.mywid;
 		uwsgi.workers[uwsgi.mywid].harakiri = 0;
-		uwsgi.workers[uwsgi.mywid].requests = 0;
-		uwsgi.workers[uwsgi.mywid].failed_requests = 0;
+		// do not reset worker counters on reload !!!
+		//uwsgi.workers[uwsgi.mywid].requests = 0;
+		//uwsgi.workers[uwsgi.mywid].failed_requests = 0;
 		uwsgi.workers[uwsgi.mywid].respawn_count++;
 		uwsgi.workers[uwsgi.mywid].last_spawn = uwsgi.current_time;
 		uwsgi.workers[uwsgi.mywid].manage_next_request = 1;
+		uwsgi.workers[uwsgi.mywid].cheaped = 0;
+		uwsgi.workers[uwsgi.mywid].busy = 0;
+		uwsgi.workers[uwsgi.mywid].sig = 0;
 
-		// close the cache server
-		if (uwsgi.cache_server_fd != -1) {
-			close(uwsgi.cache_server_fd);
-		}
+		// reset the apps count with a copy from the master 
+		uwsgi.workers[uwsgi.mywid].apps_cnt = uwsgi.workers[0].apps_cnt;
+
+		uwsgi_fixup_fds(wid, 0);
+
+                uwsgi.my_signal_socket = uwsgi.workers[wid].signal_pipe[1];
 
 		if (uwsgi.master_process) {
-			// fix the communication pipe
-			close(uwsgi.shared->worker_signal_pipe[0]);
-			for(i=1;i<=uwsgi.numproc;i++) {
-				if (uwsgi.signal_pipe[i][0] != -1) {
-					close(uwsgi.signal_pipe[i][0]);
-				}
-			}
-			uwsgi.my_signal_socket = uwsgi.signal_pipe[wid][1];
-#ifdef UWSGI_SPOOLER
-        		if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
-				if (uwsgi.shared->spooler_signal_pipe[0] != -1) close (uwsgi.shared->spooler_signal_pipe[0]);
-			}
-#endif
-			if ((uwsgi.workers[uwsgi.mywid].respawn_count || uwsgi.cheap)) {
-				for (i = 0; i < 0xFF; i++) {
-                			if (uwsgi.p[i]->master_fixup) {
-                        			uwsgi.p[i]->master_fixup(1);
-                			}
-        			}
-			}
+                        if ((uwsgi.workers[uwsgi.mywid].respawn_count || uwsgi.cheap)) {
+                                for (i = 0; i < 0xFF; i++) {
+                                        if (uwsgi.p[i]->master_fixup) {
+                                                uwsgi.p[i]->master_fixup(1);
+                                        }
+                                }
+                        }
 		}
+
 		return 1;
 	}
 	else if (pid < 1) {
 		uwsgi_error("fork()");
 	}
 	else {
-		if (uwsgi.master_process) {
-			close(uwsgi.signal_pipe[wid][1]);
-		}
 		if (respawns > 0) {
 			uwsgi_log("Respawned uWSGI worker %d (new pid: %d)\n", wid, (int) pid);
 		}
@@ -257,3 +295,115 @@ void uwsgi_manage_command_cron(time_t now) {
 
 
 }
+
+#define stats_send_llu(x, y) fprintf(output, x, (long long unsigned int) y)
+#define stats_send(x, y) fprintf(output, x, y)
+
+void uwsgi_send_stats(int fd) {
+
+	int i,j;
+	struct sockaddr_un client_src;
+	struct uwsgi_app *ua;
+	socklen_t client_src_len = 0;
+	int client_fd = accept(fd, (struct sockaddr *) &client_src, &client_src_len);
+	if (client_fd < 0) {
+		uwsgi_error("accept()");
+		return;
+	}
+
+	FILE *output = fdopen(client_fd, "w");
+	if (!output) {
+		uwsgi_error("fdopen()");
+		close(client_fd);
+		return;
+	}
+
+	stats_send("{ \"version\": \"%s\",\n", UWSGI_VERSION);
+
+#ifdef __linux__
+	stats_send_llu("\"listen_queue\": %llu,\n", uwsgi.shared->ti.tcpi_unacked);
+#endif
+
+	fprintf(output,"\"uid\": %d,\n", (int)(getuid()));
+	fprintf(output,"\"gid\": %d,\n", (int)(getgid()));
+
+	char *cwd = uwsgi_get_cwd();
+	stats_send("\"cwd\": \"%s\",\n", cwd);
+	free(cwd);
+
+	fprintf(output, "\"workers\": [\n");
+
+	for (i = 0; i < uwsgi.numproc; i++) {
+		fprintf(output,"\t{");
+
+		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("\"exceptions\": %llu, ", uwsgi.workers[i+1].exceptions);
+		stats_send_llu("\"signals\": %llu, ", uwsgi.workers[i+1].signals);
+
+		if (uwsgi.workers[i + 1].cheaped) {
+			fprintf(output,"\"status\": \"cheap\", ");
+		}
+		else {
+			if (uwsgi.workers[i + 1].sig) {
+				fprintf(output,"\"status\": \"sig%d\", ", uwsgi.workers[i + 1].signum);
+			}
+                	else if (uwsgi.workers[i + 1].busy) {
+				fprintf(output,"\"status\": \"busy\", ");
+                        }
+                        else {
+				fprintf(output,"\"status\": \"idle\", ");
+                        }
+                }
+
+		stats_send_llu("\"rss\": %llu, ", uwsgi.workers[i+1].rss_size);
+		stats_send_llu("\"vsz\": %llu, ", uwsgi.workers[i+1].vsz_size);
+
+		stats_send_llu("\"running_time\": %llu, ", uwsgi.workers[i+1].running_time);
+		stats_send_llu("\"last_spawn\": %llu, ", uwsgi.workers[i+1].last_spawn);
+		stats_send_llu("\"respawn_count\": %llu, ", uwsgi.workers[i+1].respawn_count);
+		stats_send_llu("\"tx\": %llu, ", uwsgi.workers[i+1].tx);
+		stats_send_llu("\"avg_rt\": %llu, ", uwsgi.workers[i+1].avg_response_time);
+
+		fprintf(output,"\"apps\": [\n");
+
+		for(j=0;j<uwsgi.workers[i+1].apps_cnt;j++) {
+			ua = &uwsgi.workers[i+1].apps[j];
+			fprintf(output,"\t\t{ ");
+
+			fprintf(output, "\"id\": %d, ", j);
+			fprintf(output, "\"modifier1\": %d, ", ua->modifier1);
+			fprintf(output, "\"mountpoint\": \"%.*s\", ", ua->mountpoint_len, ua->mountpoint);
+
+			stats_send_llu( "\"requests\": %llu, ", ua->requests);
+			stats_send_llu( "\"exceptions\": %llu, ", ua->exceptions);
+
+			if (ua->chdir) {
+				fprintf(output, "\"chdir\": \"%s\", ", ua->chdir);
+			}
+			else {
+				fprintf(output, "\"chdir\": \"\" ");
+			}
+			
+			if (j == uwsgi.workers[i+1].apps_cnt-1) {
+				fprintf(output,"}\n");
+			}
+			else {
+				fprintf(output,"},\n");
+			}
+		}
+
+		fprintf(output,"\t\t]");
+
+		if (i == uwsgi.numproc-1) {
+			fprintf(output,"}\n");
+		}
+		else {
+			fprintf(output,"},\n");
+		}
+	}
+
+	fprintf(output,"]}\n");
+	fclose(output);
+}

mule.c

@@ -0,0 +1,235 @@
+/*
+
+uWSGI mules are very simple workers only managing signals or running custom code in background.
+
+By default they born in signal-only mode, but if you patch them (passing the script/code to run) they will became fully customized daemons.
+
+*/
+
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+void uwsgi_mule_handler(void);
+
+void uwsgi_mule(int id) {
+
+	int i;
+
+	pid_t pid = uwsgi_fork(uwsgi.mules[id-1].name);
+	if (pid == 0) {
+		uwsgi.muleid = id;
+		// avoid race conditions
+		uwsgi.mules[id-1].id = id;
+		uwsgi.mules[id-1].pid = getpid();
+
+		uwsgi_fixup_fds(0, id);
+
+		uwsgi.my_signal_socket = uwsgi.mules[id-1].signal_pipe[1];
+		uwsgi.signal_socket = uwsgi.shared->mule_signal_pipe[1];
+
+		uwsgi_close_all_sockets();
+
+		for (i = 0; i < 0xFF; i++) {
+                	if (uwsgi.p[i]->master_fixup) {
+                		uwsgi.p[i]->master_fixup(1);
+                	}
+                }
+
+		for (i = 0; i < 0xFF; i++) {
+                        if (uwsgi.p[i]->post_fork) {
+                                uwsgi.p[i]->post_fork();
+                        }
+                }
+
+
+		if (uwsgi.mules[id-1].patch) {
+			for (i = 0; i < 0xFF; i++) {
+                        	if (uwsgi.p[i]->mule) {
+                                	if (uwsgi.p[i]->mule(uwsgi.mules[id-1].patch) == 1) {
+						// never here
+						break;
+					}
+				}
+                        }
+		}
+
+		uwsgi_mule_handler();
+	}
+	else if (pid > 0) {
+		uwsgi.mules[id-1].id = id;
+		uwsgi.mules[id-1].pid = pid;
+		uwsgi_log("spawned uWSGI mule %d (pid: %d)\n", id, (int) pid);
+	}
+}
+
+int uwsgi_farm_has_mule(struct uwsgi_farm *farm, int muleid) {
+
+	struct uwsgi_mule_farm *umf = farm->mules;
+
+	while(umf) {
+		if (umf->mule->id == muleid) {
+			return 1;
+		}
+		umf = umf->next;
+	}
+
+	return 0;
+}
+
+int farm_has_signaled(int fd) {
+
+	int i;
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+		struct uwsgi_mule_farm *umf = uwsgi.farms[i].mules;
+		while(umf) {
+			if (umf->mule->id == uwsgi.muleid && uwsgi.farms[i].signal_pipe[1] == fd) {
+				return 1;
+			}
+			umf = umf->next;
+		}
+	}
+	
+	return 0;
+}
+
+int farm_has_msg(int fd) {
+
+        int i;
+        for(i=0;i<uwsgi.farms_cnt;i++) {
+                struct uwsgi_mule_farm *umf = uwsgi.farms[i].mules;
+                while(umf) {
+                        if (umf->mule->id == uwsgi.muleid && uwsgi.farms[i].queue_pipe[1] == fd) {
+                                return 1;
+                        }
+                        umf = umf->next;
+                }
+        }
+
+        return 0;
+}
+
+
+void uwsgi_mule_add_farm_to_queue(int queue) {
+
+	int i;
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+		if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) {
+			event_queue_add_fd_read(queue, uwsgi.farms[i].signal_pipe[1]);	
+			event_queue_add_fd_read(queue, uwsgi.farms[i].queue_pipe[1]);	
+		}
+	}
+}
+
+void uwsgi_mule_handler() {
+	
+	ssize_t len;
+	uint8_t uwsgi_signal;
+	int rlen;
+	int interesting_fd;
+	
+	// this must be configurable
+	char message[65536];
+
+	int mule_queue = event_queue_init();
+
+	event_queue_add_fd_read(mule_queue, uwsgi.signal_socket);
+	event_queue_add_fd_read(mule_queue, uwsgi.my_signal_socket);
+	event_queue_add_fd_read(mule_queue, uwsgi.mules[uwsgi.muleid-1].queue_pipe[1]);
+	event_queue_add_fd_read(mule_queue, uwsgi.shared->mule_queue_pipe[1]);
+
+	uwsgi_mule_add_farm_to_queue(mule_queue);
+
+	for(;;) {
+		rlen = event_queue_wait(mule_queue, -1, &interesting_fd);
+		if (rlen <= 0) {
+			continue;
+		}
+
+		if (interesting_fd == uwsgi.signal_socket || interesting_fd == uwsgi.my_signal_socket || farm_has_signaled(interesting_fd)) {
+			len = read(interesting_fd, &uwsgi_signal, 1);
+			if (len <= 0) {
+                		uwsgi_log_verbose("uWSGI mule %d braying: my master died, i will follow him...\n", uwsgi.muleid);
+                        	end_me(0);
+                	}
+#ifdef UWSGI_DEBUG
+			uwsgi_log_verbose("master sent signal %d to mule %d\n", uwsgi_signal, uwsgi.muleid);
+#endif
+			if (uwsgi_signal_handler(uwsgi_signal)) {
+                		uwsgi_log_verbose("error managing signal %d on mule %d\n", uwsgi_signal, uwsgi.muleid);
+                	}
+		}
+		else if (interesting_fd == uwsgi.mules[uwsgi.muleid-1].queue_pipe[1] || interesting_fd == uwsgi.shared->mule_queue_pipe[1] || farm_has_msg(interesting_fd)) {
+			len = read(interesting_fd, message, 65536);
+			if (len < 0) {
+				uwsgi_error("read()");
+			}	
+			else {
+				int i,found = 0;
+				for(i=0;i<0xff;i++) {
+                                	if (uwsgi.p[i]->mule_msg) {
+                                        	if (uwsgi.p[i]->mule_msg(message, len)) {
+							found = 1;
+							break;
+						}
+					}
+                                }
+				if (!found)
+					uwsgi_log("*** mule %d received a %d bytes message ***\n", uwsgi.muleid, len);
+			}
+		}
+	}
+
+}
+
+struct uwsgi_mule *get_mule_by_id(int id) {
+
+	int i;
+
+	for(i=0;i<uwsgi.mules_cnt;i++) {
+		if (uwsgi.mules[i].id == id) {
+			return &uwsgi.mules[i];
+		}
+	}
+
+	return NULL;
+}
+
+struct uwsgi_farm *get_farm_by_name(char *name) {
+
+        int i;
+
+        for(i=0;i<uwsgi.farms_cnt;i++) {
+                if (!strcmp(uwsgi.farms[i].name, name)) {
+                        return &uwsgi.farms[i];
+                }
+        }
+
+        return NULL;
+}
+
+
+struct uwsgi_mule_farm *uwsgi_mule_farm_new(struct uwsgi_mule_farm **umf, struct uwsgi_mule *um) {
+
+        struct uwsgi_mule_farm *uwsgi_mf = *umf, *old_umf;
+
+        if (!uwsgi_mf) {
+                *umf = uwsgi_malloc(sizeof(struct uwsgi_mule_farm));
+                uwsgi_mf = *umf;
+        }
+        else {
+                while(uwsgi_mf) {
+                        old_umf = uwsgi_mf;
+			uwsgi_mf = uwsgi_mf->next;
+                }
+
+                uwsgi_mf = uwsgi_malloc(sizeof(struct uwsgi_mule_farm));
+                old_umf->next = uwsgi_mf;
+        }
+
+        uwsgi_mf->mule = um;
+        uwsgi_mf->next = NULL;
+
+        return uwsgi_mf;
+}
+

plugins/erlang/erlang.c

@@ -95,7 +95,7 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 	char buffer[0xffff];
 
 	char *argv[0xff] ;
-	int argc;
+	int argc = 0;
 	uint16_t ret;
 	ei_x_buff xr;
 
@@ -103,19 +103,20 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("%d %c %c %c\n", etype, etype, ERL_SMALL_TUPLE_EXT, ERL_LARGE_TUPLE_EXT);
+#endif
 	if (etype != ERL_SMALL_TUPLE_EXT && etype != ERL_LARGE_TUPLE_EXT) return;
 
-	uwsgi_log("decode tuple\n");
 	ei_decode_tuple_header(x->buff, &x->index, &arity);
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("rpc arity %d\n", arity);
+#endif
 	if (arity != 3) return ;
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 
-	uwsgi_log("%d %c\n", etype, etype);
-
 	if (etype != ERL_ATOM_EXT && etype != ERL_STRING_EXT) return ;
 
 	gen_call = uwsgi_malloc(esize);
@@ -127,7 +128,9 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
                 ei_decode_string(x->buff, &x->index, gen_call);
         }
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("gen call = %s\n", gen_call);
+#endif
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 	
@@ -138,13 +141,10 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 	ei_skip_term(x->buff, &x->index);
-	uwsgi_log("skip0 %d %c\n", etype, etype);
 	ei_get_type(x->buff, &x->index, &etype, &esize);
-	uwsgi_log("skip1 %d %c\n", etype, etype);
 	ei_decode_ref(x->buff, &x->index, &eref);
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
-	uwsgi_log("%d %c\n", etype, etype);
 
 	module = uwsgi_malloc(esize);
 
@@ -157,17 +157,16 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 
-	uwsgi_log("%d %c\n", etype, etype);
-
 	if (etype != ERL_SMALL_TUPLE_EXT) return ;
 
 	ei_decode_tuple_header(x->buff, &x->index, &arity);
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("arity: %d\n", arity);
+#endif
 	if (arity != 5) return ;
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
-        uwsgi_log("%d %c\n", etype, etype);
 
         char *method = uwsgi_malloc(esize);
 
@@ -181,7 +180,6 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
         if (strcmp(method, "call")) return;
 
         ei_get_type(x->buff, &x->index, &etype, &esize);
-        uwsgi_log("%d %c\n", etype, etype);
 
 	if (etype != ERL_ATOM_EXT && etype != ERL_STRING_EXT) return ;
 
@@ -207,7 +205,9 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 		ei_decode_string(x->buff, &x->index, call);
 	}
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("RPC %s %s\n", module, call);
+#endif
 
 	ei_get_type(x->buff, &x->index, &etype, &esize);
 
@@ -224,7 +224,9 @@ void uwsgi_erlang_rpc(int fd, erlang_pid *from, ei_x_buff *x) {
 
 	ret = uwsgi_rpc(call, argc, argv, buffer);
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("buffer: %.*s\n", ret, buffer);
+#endif
 
 	ei_x_new_with_version(&xr);
 
@@ -247,7 +249,6 @@ void erlang_loop() {
 	int fd;
 
 	int eversion;
-	int i;
 
 	ei_x_buff x, xr;
 
@@ -286,7 +287,7 @@ void erlang_loop() {
 					if (em.msgtype == ERL_TICK)
 						continue;
 
-					uwsgi_log("From: %s To: %s RegName: %s\n", em.from.node, em.to.node, em.toname);
+					uwsgi_log("[erlang] message From: %s To (process): %s\n", em.from.node, em.toname);
 
 
 					
@@ -300,20 +301,18 @@ void erlang_loop() {
 						uwsgi_erlang_rpc(fd, &em.from, &x);
 					}
 					else {
-						int uep = -1;
-						for(i=0;i<uerl.uep_cnt;i++) {
-							if (!strcmp(uerl.uep[i].name, em.toname)) {
-								uep = i;
+						struct uwsgi_erlang_process *uep = uerl.uep;
+						while(uep) {
+							if (!strcmp(uep->name, em.toname)) {
+								if (uep->plugin) {
+									uep->plugin(uep->func, &x);	
+								}
 								break;
 							}
+							uep = uep->next;
 						}
 
-						if (uep > -1) {
-							if (uerl.uep[uep].plugin) {
-								uerl.uep[uep].plugin( uerl.uep[uep].func, &x );
-							}
-						}
-						else {
+						if (!uep) {
 							uwsgi_log("!!! unregistered erlang process requested, dumping it !!!\n");
 							dump_eterm(&x);
 						}
@@ -366,7 +365,6 @@ int erlang_init() {
 
         if (uerl.name) {
 
-		uwsgi.master_process = 1;
 
 		host = strchr(uerl.name, '@');
 
@@ -422,10 +420,11 @@ int erlang_init() {
 		uwsgi_log("Erlang C-Node %s registered on port %d\n", ei_thisnodename(&uerl.cnode), ntohs(sin.sin_port));
 
 	
-                if (register_fat_gateway("erlang", erlang_loop) == NULL) {
+                if (register_fat_gateway("uWSGI erlang c-node", erlang_loop) == NULL) {
                         uwsgi_log("unable to register the erlang gateway\n");
                         exit(1);
                 }
+
         }
 
         return 0;
@@ -435,7 +434,8 @@ int erlang_opt(int i, char *optarg) {
 
         switch(i) {
                 case LONG_ARGS_ERLANG:
-                        uerl.name = optarg;
+			uwsgi.master_process = 1;
+			uerl.name = optarg;
                         return 1;
                 case LONG_ARGS_ERLANG_COOKIE:
 			uerl.cookie = optarg;

plugins/erlang/erlang.h

@@ -1,7 +1,5 @@
 #include <ei.h>
 
-#define MAX_UWSGI_ERLANG_PROCESSES 64
-
 #define LONG_ARGS_ERLANG                17012
 #define LONG_ARGS_ERLANG_COOKIE         17013
 
@@ -12,6 +10,8 @@ struct uwsgi_erlang_process {
 	char name[0xff];
 	void (*plugin)(void *, ei_x_buff *);
 	void *func;
+
+	struct uwsgi_erlang_process *next;
 };
 
 struct uwsgi_erlang {
@@ -24,7 +24,6 @@ struct uwsgi_erlang {
 
 	void *lock;
 
-	struct uwsgi_erlang_process uep[MAX_UWSGI_ERLANG_PROCESSES];
-	int uep_cnt;
+	struct uwsgi_erlang_process *uep;
 };
 

plugins/fastrouter/fastrouter.c

@@ -28,6 +28,8 @@
 #define FASTROUTER_STATUS_RESPONSE 4
 
 #define add_timeout(x) uwsgi_add_rb_timer(ufr.timeouts, time(NULL)+ufr.socket_timeout, x)
+#define add_check_timeout(x) uwsgi_add_rb_timer(ufr.timeouts, time(NULL)+x, NULL)
+#define del_check_timeout(x) rb_erase(&x->rbt, ufr.timeouts);
 #define del_timeout(x) rb_erase(&x->timeout->rbt, ufr.timeouts); free(x->timeout);
 
 struct uwsgi_fastrouter_socket {
@@ -43,6 +45,8 @@ struct uwsgi_fastrouter {
         int use_cache;
         int nevents;
 
+	int queue;
+
         int subscription_slot;
 
         char *pattern;
@@ -52,7 +56,8 @@ struct uwsgi_fastrouter {
         int base_len;
 
         char *subscription_server;
-        struct uwsgi_dict *subscription_dict;
+        struct uwsgi_subscribe_slot *subscriptions;
+	int subscription_regexp;
 
         int socket_timeout;
 
@@ -61,6 +66,11 @@ struct uwsgi_fastrouter {
 	char *code_string_function;
 
         struct rb_root *timeouts;
+
+	struct uwsgi_rb_timer *subscriptions_check;
+
+	int cheap;
+	int i_am_cheap;
 } ufr;
 
 
@@ -97,8 +107,10 @@ struct option fastrouter_options[] = {
 	{"fastrouter-use-base", required_argument, 0, LONG_ARGS_FASTROUTER_USE_BASE},
 	{"fastrouter-use-code-string", required_argument, 0, LONG_ARGS_FASTROUTER_USE_CODE_STRING},
 	{"fastrouter-events", required_argument, 0, LONG_ARGS_FASTROUTER_EVENTS},
+	{"fastrouter-cheap", no_argument, &ufr.cheap, 1},
 	{"fastrouter-subscription-server", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER},
 	{"fastrouter-subscription-slot", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT},
+	{"fastrouter-subscription-use-regexp", no_argument, &ufr.subscription_regexp, 1},
 	{"fastrouter-timeout", required_argument, 0, LONG_ARGS_FASTROUTER_TIMEOUT},
 	{0, 0, 0, 0},	
 };
@@ -130,7 +142,6 @@ struct fastrouter_session {
 	int status;
 	struct uwsgi_header uh;
 	uint8_t h_pos;
-	char buffer[0xffff];
 	uint16_t pos;
 
 	char *hostname;
@@ -141,23 +152,57 @@ struct fastrouter_session {
 	char *instance_address;
 	uint64_t instance_address_len;
 
-	struct uwsgi_subscriber_name *un;
+	struct uwsgi_subscribe_node *un;
 	int pass_fd;
 
 	struct uwsgi_rb_timer *timeout;
 	int instance_failed;
 
 	uint8_t modifier1;
+
+	char buffer[0xffff];
 };
 
 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.subscription_server && (fr_session->instance_failed || fr_session->status == FASTROUTER_STATUS_CONNECTING)) {
-			uwsgi_log("marking %.*s as failed\n", (int) fr_session->instance_address_len,fr_session->instance_address);
-			fr_session->un->len = 0;
+		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 == 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;
+                                }
+
+			}
 		}
 		close(fr_session->instance_fd);
 		fr_table[fr_session->instance_fd] = NULL;
@@ -182,7 +227,6 @@ static void expire_timeouts(struct fastrouter_session **fr_table) {
 
 		if (urbt->key <= current) {
 			close_session(fr_table, (struct fastrouter_session *)urbt->data);
-			uwsgi_log("timeout !!!\n");
 			continue;
 		}
 
@@ -222,7 +266,6 @@ struct fastrouter_session *alloc_fr_session() {
 
 void fastrouter_loop() {
 
-	int fr_queue;
 	int nevents;
 	int interesting_fd;
 	int new_connection;
@@ -269,7 +312,7 @@ void fastrouter_loop() {
 		fr_table[i] = NULL;
 	}
 
-	fr_queue = event_queue_init();
+	ufr.queue = event_queue_init();
 
 	struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
 
@@ -295,27 +338,35 @@ void fastrouter_loop() {
 
 		uwsgi_log("uwsgi fastrouter/proxy bound on %s\n", ufr_sock->name);
 
-		event_queue_add_fd_read(fr_queue, ufr_sock->fd);
+		if (!ufr.cheap) {
+			event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
+		}
+		else {
+			uwsgi_log("[uwsgi-fastrouter] cheap mode requested. Waiting for subscriptions...\n");
+			ufr.i_am_cheap = 1;
+		}
 		ufr_sock = ufr_sock->next;
 	}
 
 
 	events = event_queue_alloc(ufr.nevents);
 
+	ufr.timeouts = uwsgi_init_rb_timer();
+	if (!ufr.socket_timeout) ufr.socket_timeout = 30;
+
 
 	if (ufr.subscription_server) {
 		ufr_subserver = bind_to_udp(ufr.subscription_server, 0, 0);
-		event_queue_add_fd_read(fr_queue, ufr_subserver);
+		event_queue_add_fd_read(ufr.queue, ufr_subserver);
 		if (!ufr.subscription_slot) ufr.subscription_slot = 30;
-		ufr.subscription_dict = uwsgi_dict_create(ufr.subscription_slot, 0);
+		// check for node status every 10 seconds
+		//ufr.subscriptions_check = add_check_timeout(10);
 	}
 
 	if (ufr.pattern) {
 		init_magic_table(magic_table);
 	}
 
-	ufr.timeouts = uwsgi_init_rb_timer();
-	if (!ufr.socket_timeout) ufr.socket_timeout = 30;
 
 	for (;;) {
 
@@ -331,7 +382,7 @@ void fastrouter_loop() {
 			}
 		}
 
-		nevents = event_queue_wait_multi(fr_queue, delta, events, ufr.nevents);
+		nevents = event_queue_wait_multi(ufr.queue, delta, events, ufr.nevents);
 
 		if (nevents == 0) {
 			expire_timeouts(fr_table);
@@ -361,10 +412,12 @@ void fastrouter_loop() {
 					fr_table[new_connection]->un = NULL;
 					fr_table[new_connection]->instance_failed = 0;
 					fr_table[new_connection]->instance_address_len = 0;
+					fr_table[new_connection]->hostname_len = 0;
+					fr_table[new_connection]->hostname = NULL;
 		
 					fr_table[new_connection]->timeout = add_timeout(fr_table[new_connection]);
 
-					event_queue_add_fd_read(fr_queue, new_connection);
+					event_queue_add_fd_read(ufr.queue, new_connection);
 					taken = 1;
 					break;
 				}
@@ -379,12 +432,20 @@ void fastrouter_loop() {
 			if (interesting_fd == ufr_subserver) {
 				len = recv(ufr_subserver, bbuf, 4096, 0);
 #ifdef UWSGI_EVENT_USE_PORT
-				event_queue_add_fd_read(fr_queue, ufr_subserver);
+				event_queue_add_fd_read(ufr.queue, ufr_subserver);
 #endif
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
-					uwsgi_add_subscriber(ufr.subscription_dict, &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");	
+					}
 				}
 			}
 			else {
@@ -439,7 +500,7 @@ void fastrouter_loop() {
 							}
 
 #ifdef UWSGI_DEBUG
-							uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
+							//uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
 #endif
 							if (ufr.use_cache) {
 								fr_session->instance_address = uwsgi_cache_get(fr_session->hostname, fr_session->hostname_len, &fr_session->instance_address_len);
@@ -457,7 +518,7 @@ void fastrouter_loop() {
 								fr_session->instance_address = tmp_socket_name;
 							}
 							else if (ufr.subscription_server) {
-								fr_session->un = uwsgi_get_subscriber(ufr.subscription_dict, fr_session->hostname, fr_session->hostname_len);
+								fr_session->un = uwsgi_get_subscribe_node(&ufr.subscriptions, fr_session->hostname, fr_session->hostname_len, ufr.subscription_regexp);
 								if (fr_session->un && fr_session->un->len) {
 									fr_session->instance_address = fr_session->un->name;
 									fr_session->instance_address_len = fr_session->un->len;
@@ -497,10 +558,24 @@ void fastrouter_loop() {
 							if (tmp_socket_name) free(tmp_socket_name);
 
 							if (fr_session->instance_fd < 0) {
+								/*
 								if (ufr.subscription_server) {
-	                                                        	uwsgi_log("marking %.*s as failed\n", (int) fr_session->instance_address_len,fr_session->instance_address);
-	                                                        	fr_session->un->len = 0;
+									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;
 							}
@@ -508,7 +583,7 @@ void fastrouter_loop() {
 
 							fr_session->status = FASTROUTER_STATUS_CONNECTING;
 							fr_table[fr_session->instance_fd] = fr_session;
-							event_queue_add_fd_write(fr_queue, fr_session->instance_fd);
+							event_queue_add_fd_write(ufr.queue, fr_session->instance_fd);
                                                 }
                                                 break;
 
@@ -574,7 +649,7 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
-							event_queue_fd_write_to_read(fr_queue, fr_session->instance_fd);
+							event_queue_fd_write_to_read(ufr.queue, fr_session->instance_fd);
 							fr_session->status = FASTROUTER_STATUS_RESPONSE;
 						}
 
@@ -630,7 +705,7 @@ void fastrouter_loop() {
 
 					// fallback to destroy !!!
 					default:
-						uwsgi_log("default action\n");
+						uwsgi_log("unknown event: closing session\n");
 						close_session(fr_table, fr_session);
 						break;
 					
@@ -653,13 +728,13 @@ int fastrouter_init() {
 		if (!ufr.nevents) ufr.nevents = 64;
 
 		if (ufr.code_string_code && ufr.code_string_function) {
-			if (register_fat_gateway("fastrouter", fastrouter_loop) == NULL) {
+			if (register_fat_gateway("uWSGI fastrouter", fastrouter_loop) == NULL) {
 				uwsgi_log("unable to register the fastrouter gateway\n");
 				exit(1);
 			}
 		}
 		else {
-			if (register_gateway("fastrouter", fastrouter_loop) == NULL) {
+			if (register_gateway("uWSGI fastrouter", fastrouter_loop) == NULL) {
 				uwsgi_log("unable to register the fastrouter gateway\n");
 				exit(1);
 			}

plugins/http/http.c

@@ -39,6 +39,7 @@ struct uwsgi_http {
 	int server;
 
 	char *subscription_server;
+	int subscription_regexp;
 
 	char *pattern;
 	int pattern_len;
@@ -60,7 +61,7 @@ struct uwsgi_http {
 
 	int socket_timeout;
 
-	struct uwsgi_dict *subscription_dict;
+	struct uwsgi_subscribe_slot *subscriptions;
 
 	struct rb_root *timeouts;
 } uhttp;
@@ -76,6 +77,7 @@ struct option http_options[] = {
 	{"http-use-cluster", no_argument, &uhttp.use_cluster, 1},
 	{"http-events", required_argument, 0, LONG_ARGS_HTTP_EVENTS},
 	{"http-subscription-server", required_argument, 0, LONG_ARGS_HTTP_SUBSCRIPTION_SERVER},
+	{"http-subscription-use-regexp", no_argument, &uhttp.subscription_regexp, 1},
 	{"http-timeout", required_argument, 0, LONG_ARGS_HTTP_TIMEOUT},
 	{0, 0, 0, 0},	
 };
@@ -136,8 +138,10 @@ struct http_session {
 	char uss[MAX_HTTP_VEC*2];
 
 	char buffer[UMAX16];
+	char path_info[UMAX16];
+	uint16_t path_info_len;
 
-	struct uwsgi_subscriber_name *un;
+	struct uwsgi_subscribe_node *un;
 	
 	in_addr_t ip_addr;
 	char ip[INET_ADDRSTRLEN];
@@ -156,9 +160,9 @@ static void close_session(struct http_session **uhttp_table, struct http_session
 	close(uhttp_session->fd);
         uhttp_table[uhttp_session->fd] = NULL;
         if (uhttp_session->instance_fd != -1) {
-        	if (uhttp.subscription_server && (uhttp_session->instance_failed || uhttp_session->status == HTTP_STATUS_CONNECTING)) {
+        	if (uhttp.subscriptions && (uhttp_session->instance_failed || uhttp_session->status == HTTP_STATUS_CONNECTING)) {
                 	uwsgi_log("marking %.*s as failed\n", (int) uhttp_session->instance_address_len,uhttp_session->instance_address);
-                        uhttp_session->un->len = 0;
+			uwsgi_remove_subscribe_node(&uhttp.subscriptions, uhttp_session->un);
                 }
                 close(uhttp_session->instance_fd);
                 uhttp_table[uhttp_session->instance_fd] = NULL;
@@ -325,13 +329,19 @@ int http_parse(struct http_session *h_session) {
 	base = ptr;
 	while(ptr < watermark) {
                 if (*ptr == '?' && !query_string) {
-			h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "PATH_INFO", 9, base, ptr-base, &c);
+			// PATH_INFO must be url-decoded !!!
+			h_session->path_info_len = ptr-base;
+			http_url_decode(base, &h_session->path_info_len, h_session->path_info);
+			h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "PATH_INFO", 9, h_session->path_info, h_session->path_info_len, &c);
 			query_string = ptr+1;
 		}
                 else if (*ptr == ' ') {
 			h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "REQUEST_URI", 11, base, ptr-base, &c);
 			if (!query_string) {
-				h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "PATH_INFO", 9, base, ptr-base, &c);
+				// PATH_INFO must be url-decoded !!!
+				h_session->path_info_len = ptr-base;
+				http_url_decode(base, &h_session->path_info_len, h_session->path_info);
+				h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "PATH_INFO", 9, h_session->path_info, h_session->path_info_len, &c);
 				h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "QUERY_STRING", 12, "", 0, &c);
 			}	
 			else {
@@ -474,7 +484,6 @@ void http_loop() {
 	if (uhttp.subscription_server) {
 		uhttp_subserver = bind_to_udp(uhttp.subscription_server, 0, 0);
 		event_queue_add_fd_read(uhttp_queue, uhttp_subserver);
-		uhttp.subscription_dict = uwsgi_dict_create(100, 0);
 	}
 
 	if (uhttp.pattern) {
@@ -550,7 +559,7 @@ void http_loop() {
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, http_manage_subscription, &usr);
-					uwsgi_add_subscriber(uhttp.subscription_dict, &usr);
+					uwsgi_add_subscribe_node(&uhttp.subscriptions, &usr, uhttp.subscription_regexp);
 				}
 			}
 			else {
@@ -630,7 +639,7 @@ void http_loop() {
 									uhttp_session->instance_address_len = uhttp.to_len;
 								}
 								else if (uhttp.subscription_server) {
-									uhttp_session->un = uwsgi_get_subscriber(uhttp.subscription_dict, uhttp_session->hostname, uhttp_session->hostname_len);
+									uhttp_session->un = uwsgi_get_subscribe_node(&uhttp.subscriptions, uhttp_session->hostname, uhttp_session->hostname_len, uhttp.subscription_regexp);
 									if (uhttp_session->un && uhttp_session->un->len) {
 										uhttp_session->instance_address = uhttp_session->un->name;
 										uhttp_session->instance_address_len = uhttp_session->un->len;
@@ -647,6 +656,7 @@ void http_loop() {
 								}
 
 
+
 								uhttp_session->pass_fd = is_unix(uhttp_session->instance_address, uhttp_session->instance_address_len);
 
 								uhttp_session->instance_fd = uwsgi_connectn(uhttp_session->instance_address, uhttp_session->instance_address_len, 0, 1);
@@ -660,10 +670,7 @@ void http_loop() {
 								}
 
 								if (uhttp_session->instance_fd < 0) {
-									if (uhttp.subscription_server) {
-										uwsgi_log("marking %.*s as failed\n", (int) uhttp_session->instance_address_len,uhttp_session->instance_address);
-										uhttp_session->un->len = 0;
-									}
+									uhttp_session->instance_failed = 1;
 									close_session(uhttp_table, uhttp_session);
                                                                 	break;
                                                         	}
@@ -882,7 +889,7 @@ int http_init() {
 
 		uhttp.server = bind_to_tcp(uhttp.socket_name, uwsgi.listen_queue, strchr(uhttp.socket_name,':'));
 
-		if (register_gateway("http", http_loop) == NULL) {
+		if (register_gateway("uWSGI http", http_loop) == NULL) {
 			uwsgi_log("unable to register the http gateway\n");
 			exit(1);
 		}

plugins/psgi/psgi.h

@@ -34,7 +34,7 @@ struct uwsgi_perl {
 
 void init_perl_embedded_module(void);
 void uwsgi_psgi_app(void);
-int psgi_response(struct wsgi_request *, PerlInterpreter *, AV*);
+int psgi_response(struct wsgi_request *, AV*);
 
 #define psgi_xs(func) newXS("uwsgi::" #func, XS_##func, "uwsgi")
 #define psgi_check_args(x) if (items < x) Perl_croak(aTHX_ "Usage: uwsgi::%s takes %d arguments", __FUNCTION__ + 3, x)

plugins/psgi/psgi_loader.c

@@ -41,19 +41,11 @@ XS(XS_stream)
     AV *response = (AV* ) SvREFCNT_inc(SvRV(ST(0))) ;
 
 	if (av_len(response) == 2) {
-
-#ifdef my_perl
-		while (psgi_response(wsgi_req, my_perl, response) != UWSGI_OK);
-#else
-		while (psgi_response(wsgi_req, uperl.main, response) != UWSGI_OK);
-#endif
+		while (psgi_response(wsgi_req, response) != UWSGI_OK);
 	}
 	else if (av_len(response) == 1) {
-#ifdef my_perl
-		while (psgi_response(wsgi_req, my_perl, response) != UWSGI_OK);
-#else
-		while (psgi_response(wsgi_req, uperl.main, response) != UWSGI_OK);
-#endif
+		while (psgi_response(wsgi_req, response) != UWSGI_OK);
+
 		SvREFCNT_dec(response);
                 ST(0) = sv_bless(newRV(sv_newmortal()), uperl.streaming_stash);
                 XSRETURN(1);
@@ -236,6 +228,7 @@ xs_init(pTHX)
 void uwsgi_psgi_app() {
 
         struct stat stat_psgi;
+	int id = uwsgi_apps_cnt;
 
         if (uperl.psgi) {
 
@@ -291,7 +284,6 @@ void uwsgi_psgi_app() {
 
                 uperl.psgibuffer[stat_psgi.st_size] = 0;
 
-                if (uwsgi.threads < 2) {
                         uperl.psgi_main = perl_eval_pv(uwsgi_concat4("#line 1 ", uperl.psgi, "\n", uperl.psgibuffer), 0);
                         if (!uperl.psgi_main) {
                                 uwsgi_log("unable to find PSGI function entry point.\n");
@@ -303,11 +295,31 @@ void uwsgi_psgi_app() {
                                 exit(1);
                         }
 
+                if (uwsgi.threads < 2) {
                         free(uperl.psgibuffer);
                         close(uperl.fd);
-                }
+		}
+
+		struct uwsgi_app *wi = &uwsgi_apps[id];
+		memset(wi, 0, sizeof(struct uwsgi_app));
+
+		wi->modifier1 = 5;
+		wi->mountpoint = "";
+		wi->mountpoint_len = 0;
+
+                uwsgi_log("PSGI app %d (%s) loaded at %p\n", id, uperl.psgi, uperl.psgi_main);
+
+		uwsgi_apps_cnt++;
+	
+		// check if we need to emulate fork() COW
+		int i;
+        	if (uwsgi.mywid == 0) {
+                	for(i=1;i<=uwsgi.numproc;i++) {
+                        	memcpy(&uwsgi.workers[i].apps[id], &uwsgi.workers[0].apps[id], sizeof(struct uwsgi_app));
+                        	uwsgi.workers[i].apps_cnt = uwsgi_apps_cnt;
+                	}
+        	}
 
-                uwsgi_log("PSGI app (%s) loaded at %p\n", uperl.psgi, uperl.psgi_main);
         }
 
 

plugins/psgi/psgi_plugin.c

@@ -23,7 +23,7 @@ SV *uwsgi_perl_obj_new(char *class, size_t class_len) {
 
 	SV *newobj;
 	// set current context ?
-	//dTHX;
+	dTHX;
 	dSP;
 
 	ENTER;
@@ -49,7 +49,7 @@ SV *uwsgi_perl_call_stream(SV *func) {
 
 	SV *ret = NULL;
         // set current context ?
-        //dTHX;
+        dTHX;
         dSP;
 
         ENTER;
@@ -79,7 +79,7 @@ int uwsgi_perl_obj_can(SV *obj, char *method, size_t len) {
 
 	int ret;
         // set current context ? needed for threading
-        //dTHX;
+        dTHX;
         dSP;
 
         ENTER;
@@ -107,6 +107,7 @@ SV *uwsgi_perl_obj_call(SV *obj, char *method) {
 
         SV *ret = NULL;
 
+	dTHX;
         dSP;
 
         ENTER;
@@ -140,6 +141,7 @@ AV *psgi_call(struct wsgi_request *wsgi_req, SV *psgi_func, SV *env) {
 
 	AV *ret = NULL;
 
+	dTHX;
         dSP;
 
         ENTER;
@@ -149,6 +151,7 @@ AV *psgi_call(struct wsgi_request *wsgi_req, SV *psgi_func, SV *env) {
 	PUTBACK;
 
 	call_sv(psgi_func, G_SCALAR | G_EVAL);
+
 	SPAGAIN;
 
         if(SvTRUE(ERRSV)) {
@@ -280,7 +283,7 @@ int uwsgi_perl_init(){
 
 	struct http_status_codes *http_sc;
 
-	int argc = 3;
+	int argc;
 	uperl.embedding[0] = "";
 	uperl.embedding[1] = "-e";
 	uperl.embedding[2] = "0";
@@ -298,6 +301,9 @@ int uwsgi_perl_init(){
 #else
 	uwsgi_log("initializing Perl environment\n");
 #endif
+
+	argc = 3;
+
 	PERL_SYS_INIT3(&argc, (char ***) &uperl.embedding, &environ);
 	uperl.main = perl_alloc();
 	if (!uperl.main) {
@@ -323,51 +329,19 @@ int uwsgi_perl_init(){
 
 }
 
-#ifdef my_perl
+#ifdef USE_ITHREADS
 void uwsgi_perl_enable_threads() {
 	
-	int i;
-
 	if (pthread_key_create(&uperl.u_interpreter, NULL)) {
         	uwsgi_error("pthread_key_create()");
                 exit(1);
 	}
 
-	uperl.interp = malloc( sizeof(PerlInterpreter*) * uwsgi.threads );
-	if (!uperl.interp) {
-		uwsgi_error("malloc()");
-		exit(1);
-	}
+	uperl.interp = uwsgi_malloc( sizeof(PerlInterpreter*) * uwsgi.threads );
+	uperl.interp[0] = uperl.main;
 
-	for(i=1;i<uwsgi.threads;i++) {
-		uperl.interp[i] = perl_clone(uperl.main, CLONEf_KEEP_PTR_TABLE);
-		if (!uperl.interp[i]) {
-			uwsgi_log("unable to create new perl interpreter\n");
-			exit(1);
-		}
-	}
+	uperl.psgi_func = uwsgi_malloc( sizeof(SV*) * uwsgi.threads );
 
-	uperl.psgi_func = malloc( sizeof(SV*) * uwsgi.threads );
-	if (!uperl.psgi_func) {
-		uwsgi_error("malloc()");
-		exit(1);
-	}
-	
-
-	dTHXa(uperl.main);
-	PERL_SET_CONTEXT(uperl.main);
-
-	uperl.psgi_main = perl_eval_pv(uperl.psgibuffer, 0);
-	if (!uperl.psgi_main) {
-		uwsgi_log("unable to find PSGI function entry point.\n");
-		exit(1);
-	}
-
-	if(SvTRUE(ERRSV)) {
-		uwsgi_log("%s\n", SvPV_nolen(ERRSV));
-		exit(1);
-	}
-	
 
 }
 #endif
@@ -378,12 +352,10 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 
 	SV **harakiri;
 	SV *psgi_func = uperl.psgi_main;
-	// ugly hack
-	register PerlInterpreter *my_perl = uperl.main;
 
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
-		return psgi_response(wsgi_req, my_perl, wsgi_req->async_placeholder);	
+		return psgi_response(wsgi_req, wsgi_req->async_placeholder);	
 	}
 #endif
 
@@ -398,19 +370,14 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 		return -1;
 	}
 
-
-#ifdef UWSGI_THREADING
-	if (uwsgi.threads > 1 && wsgi_req->async_id > 0) {
+	if (uwsgi.threads > 1) {
 		psgi_func = uperl.psgi_func[wsgi_req->async_id];
-		my_perl = pthread_getspecific(uperl.u_interpreter);
 	}
-#endif
-
 
+	
 	ENTER;
 	SAVETMPS;
 
-
 	wsgi_req->async_environ = build_psgi_env(wsgi_req);
 	if (!wsgi_req->async_environ) goto clear;
 
@@ -428,7 +395,7 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 		goto clear2;
 	}
 
-	while (psgi_response(wsgi_req, my_perl, wsgi_req->async_result) != UWSGI_OK) {
+	while (psgi_response(wsgi_req, wsgi_req->async_result) != UWSGI_OK) {
 #ifdef UWSGI_ASYNC
 		if (uwsgi.async > 1) {
 			FREETMPS;
@@ -468,26 +435,41 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
 
 }
 
+#ifdef USE_ITHREADS
 void uwsgi_perl_init_thread(int core_id) {
 
 
-	pthread_setspecific(uperl.u_interpreter, uperl.interp[core_id]);
+
+	if (core_id > 0) {
+		uperl.interp[core_id] = perl_clone(uperl.main, CLONEf_KEEP_PTR_TABLE);
+                if (!uperl.interp[core_id]) {
+                        uwsgi_log("unable to create new perl interpreter\n");
+                        exit(1);
+                }
+	}
+
 	dTHXa(uperl.interp[core_id]);
 	PERL_SET_CONTEXT(uperl.interp[core_id]);
 
-	uperl.psgi_func[core_id] = perl_eval_pv(uperl.psgibuffer, 0);
-        if (!uperl.psgi_func[core_id]) {
-        	uwsgi_log("unable to find PSGI function entry point.\n");
-		exit(1);
-        }
+	pthread_setspecific(uperl.u_interpreter, uperl.interp[core_id]);
 
-        if(SvTRUE(ERRSV)) {
-        	uwsgi_log("%s\n", SvPV_nolen(ERRSV));
-		exit(1);
-        }
+	uperl.psgi_func[0] = uperl.psgi_main;
+	if (core_id > 0) {
+		uperl.psgi_func[core_id] = perl_eval_pv(uwsgi_concat4("#line 1 ", uperl.psgi, "\n", uperl.psgibuffer), 0);
 
+        	if (!uperl.psgi_func[core_id]) {
+        		uwsgi_log("unable to find PSGI function entry point.\n");
+                	exit(1);
+        	}
+
+        	if(SvTRUE(ERRSV)) {
+        		uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+                	exit(1);
+        	}
+	}
 
 }
+#endif
 
 int uwsgi_perl_manage_options(int i, char *optarg) {
 
@@ -528,11 +510,11 @@ struct uwsgi_plugin psgi_plugin = {
 	.init_apps = uwsgi_psgi_app,
 	//.magic = uwsgi_perl_magic,
 	//.help = uwsgi_perl_help,
-#ifdef my_perl
+#ifdef USE_ITHREADS
 	.enable_threads = uwsgi_perl_enable_threads,
+	.init_thread = uwsgi_perl_init_thread,
 #endif
 	.manage_opt = uwsgi_perl_manage_options,
-	.init_thread = uwsgi_perl_init_thread,
 	.request = uwsgi_perl_request,
 	.after_request = uwsgi_perl_after_request,
 

plugins/psgi/psgi_response.c

@@ -4,7 +4,7 @@ extern struct uwsgi_server uwsgi;
 
 extern struct http_status_codes hsc[];
 
-int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *response) {
+int psgi_response(struct wsgi_request *wsgi_req, AV *response) {
 
 	SV **status_code, **hitem ;
 	AV *headers, *body =NULL;

plugins/psgi/uwsgiplugin.py

@@ -1,7 +1,11 @@
 import os,sys
 
 NAME='psgi'
-CFLAGS = [os.popen('perl -MExtUtils::Embed -e ccopts').read().rstrip()]
-LDFLAGS = [os.popen('perl -MExtUtils::Embed -e ldopts').read().rstrip()]
+CFLAGS = os.popen('perl -MExtUtils::Embed -e ccopts').read().rstrip().split()
+LDFLAGS = os.popen('perl -MExtUtils::Embed -e ldopts').read().rstrip().split()
 LIBS = []
 GCC_LIST = ['uwsgi_plmodule', 'psgi_loader', 'psgi_response', 'psgi_plugin']
+
+for item in LDFLAGS:
+    if item.endswith('DynaLoader.a'):
+        GCC_LIST.append(item)

plugins/pyerl/pyerl.c

@@ -304,7 +304,7 @@ void pyerl_call_registered(void *func, ei_x_buff *x) {
 
 	PyTuple_SetItem(pyargs, 0, erl_to_py(x));
 	
-        python_call((PyObject *) func, pyargs, 0);
+        python_call((PyObject *) func, pyargs, 0, NULL);
 }
 
 PyObject *pyerl_register_process(PyObject * self, PyObject * args) {
@@ -316,17 +316,30 @@ PyObject *pyerl_register_process(PyObject * self, PyObject * args) {
                 return NULL;
         }
 
-	if (uerl.uep_cnt >= MAX_UWSGI_ERLANG_PROCESSES)
-	return PyErr_Format(PyExc_ValueError, "You can define max %d erlang registered processes", MAX_UWSGI_ERLANG_PROCESSES);
-
 	if (strlen(name) > 0xff-1)
 	return PyErr_Format(PyExc_ValueError, "Invalid erlang process name");
 
-	strcpy(uerl.uep[uerl.uep_cnt].name, name);
-	uerl.uep[uerl.uep_cnt].plugin = pyerl_call_registered;
-	uerl.uep[uerl.uep_cnt].func = callable;
+	struct uwsgi_erlang_process *uep = uerl.uep, *old_uep;
+
+        if (!uep) {
+                uerl.uep = uwsgi_malloc(sizeof(struct uwsgi_erlang_process));
+                uep = uerl.uep;
+        }
+        else {
+                while(uep) {
+                        old_uep = uep;
+                        uep = uep->next;
+                }
+
+                uep = uwsgi_malloc(sizeof(struct uwsgi_erlang_process));
+                old_uep->next = uep;
+        }
+
+	strcpy(uep->name, name);
+	uep->plugin = pyerl_call_registered;
+	uep->func = callable;
+        uep->next = NULL;
 
-	uerl.uep_cnt++;
 
 	Py_INCREF(Py_None);
 	return Py_None;

plugins/python/gil.c

@@ -3,6 +3,11 @@
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
+#ifdef UWSGI_PYPY
+void gil_real_get() {}
+void gil_real_release() {}
+#else
+
 void gil_real_get() {
 	//uwsgi_log("LOCK %d\n", uwsgi.mywid);
 #ifndef PYTHREE
@@ -26,5 +31,7 @@ void gil_real_release() {
 #endif
 }
 
+#endif
+
 void gil_fake_get() {}
 void gil_fake_release() {}

plugins/python/profiler.c

@@ -15,6 +15,7 @@ int PyFrame_GetLineNumber(PyFrameObject *frame) {
 
 int uwsgi_python_profiler_call(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg) {
 
+#ifndef UWSGI_PYPY
 	switch(what) {
 		case PyTrace_CALL:
 			uwsgi_log("[uWSGI Python profiler] CALL: %s (line %d) -> %s %d args, stacksize %d\n",
@@ -29,6 +30,7 @@ int uwsgi_python_profiler_call(PyObject *obj, PyFrameObject *frame, int what, Py
 				PyEval_GetFuncName(arg), frame->f_code->co_argcount, frame->f_code->co_stacksize);
 			break;
 	}
+#endif
 
 	return 0;
 }

plugins/python/pump_subhandler.c

@@ -257,7 +257,11 @@ int uwsgi_response_subhandler_pump(struct wsgi_request *wsgi_req) {
                 	wsgi_req->headers_size += wsize;
 
 			PyObject *hhkey, *hhvalue;
+#ifdef UWSGI_PYTHON_OLD
+			int hhpos = 0;
+#else
 			Py_ssize_t hhpos = 0;
+#endif
 			while (PyDict_Next(headers, &hhpos, &hhkey, &hhvalue)) {
 				if (!PyString_Check(hhkey)) continue;
 

plugins/python/pyloader.c

@@ -22,6 +22,57 @@ PyMethodDef uwsgi_eventfd_read_method[] = { {"uwsgi_eventfd_read", py_eventfd_re
 PyMethodDef uwsgi_eventfd_write_method[] = { {"uwsgi_eventfd_write", py_eventfd_write, METH_VARARGS, ""}};
 #endif
 
+#ifdef UWSGI_MINTERPRETERS
+
+void set_dyn_pyhome(char *home, uint16_t pyhome_len) {
+
+
+	char venv_version[15];
+	PyObject *site_module;
+
+	PyObject *pysys_dict = get_uwsgi_pydict("sys");
+
+	PyObject *pypath = pypath = PyDict_GetItemString(pysys_dict, "path");
+	if (!pypath) {
+		PyErr_Print();
+		exit(1);
+	}
+
+        // simulate a pythonhome directive
+        if (uwsgi.wsgi_req->pyhome_len > 0) {
+
+                PyObject *venv_path = UWSGI_PYFROMSTRINGSIZE(uwsgi.wsgi_req->pyhome, uwsgi.wsgi_req->pyhome_len);
+
+#ifdef UWSGI_DEBUG
+                uwsgi_debug("setting dynamic virtualenv to %.*s\n", uwsgi.wsgi_req->pyhome_len, uwsgi.wsgi_req->pyhome);
+#endif
+
+                PyDict_SetItemString(pysys_dict, "prefix", venv_path);
+                PyDict_SetItemString(pysys_dict, "exec_prefix", venv_path);
+
+                venv_version[14] = 0;
+                if (snprintf(venv_version, 15, "/lib/python%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION) == -1) {
+                        return;
+                }
+
+                // check here
+                PyString_Concat(&venv_path, PyString_FromString(venv_version));
+
+                if (PyList_Insert(pypath, 0, venv_path)) {
+                        PyErr_Print();
+                }
+
+                site_module = PyImport_ImportModule("site");
+                if (site_module) {
+                        PyImport_ReloadModule(site_module);
+                }
+
+        }
+}
+
+#endif
+
+
 int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter, int app_type) {
 
 	PyObject *app_list = NULL, *applications = NULL;
@@ -94,7 +145,9 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
                                 		continue;
                         		}
 	
+#ifdef UWSGI_DEBUG
 					uwsgi_log("%s = %s\n", PyString_AsString(k), PyString_AsString(env_value));
+#endif
 
                         		if (PyObject_SetItem(py_environ, k, env_value)) {
                                 		PyErr_Print();
@@ -109,7 +162,9 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
         	}
 	}
 
+#ifdef UWSGI_MINTERPRETERS
 	if (interpreter == NULL && id) {
+
 		wi->interpreter = Py_NewInterpreter();
 		if (!wi->interpreter) {
 			uwsgi_log( "unable to initialize the new python interpreter\n");
@@ -132,6 +187,13 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		wi->interpreter = up.main_thread;
 	}
 
+	if (wsgi_req->pyhome_len) {
+		set_dyn_pyhome(wsgi_req->pyhome, wsgi_req->pyhome_len);
+	}
+#else
+	wi->interpreter = up.main_thread;
+#endif
+
 	if (wsgi_req->touch_reload_len) {
 		struct stat trst;
 		char *touch_reload = uwsgi_strncopy(wsgi_req->touch_reload, wsgi_req->touch_reload_len);
@@ -144,7 +206,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	wi->callable = up.loaders[loader](arg1);
 
 	if (!wi->callable) {
-		uwsgi_log("unable to load app mountpoint=%s\n", mountpoint);
+		uwsgi_log("unable to load app %d (mountpoint='%s') (callable not found or import error)\n", id, mountpoint);
 		goto doh;
 	}
 
@@ -309,13 +371,13 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 
 	if (app_type == PYTHON_APP_TYPE_WSGI) {
-		uwsgi_log( "WSGI application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+		uwsgi_log( "WSGI application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 	else if (app_type == PYTHON_APP_TYPE_WEB3) {
-		uwsgi_log( "Web3 application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+		uwsgi_log( "Web3 application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 	else if (app_type == PYTHON_APP_TYPE_PUMP) {
-		uwsgi_log( "Pump application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+		uwsgi_log( "Pump application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 
 	if ((wsgi_req->appid_len == 0 || (wsgi_req->appid_len = 1 && wsgi_req->appid[0] == '/')) && uwsgi.default_app == -1) {
@@ -366,6 +428,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 doh:
 	free(mountpoint);
 	PyErr_Print();
+#ifdef UWSGI_MINTERPRETERS
 	if (interpreter == NULL && id) {
 		Py_EndInterpreter(wi->interpreter);
 		if (uwsgi.threads > 1) {
@@ -375,6 +438,7 @@ doh:
 			PyThreadState_Swap(up.main_thread);
 		}
 	}
+#endif
 	return -1;
 }
 
@@ -419,7 +483,9 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 
 	PyObject *tmp_callable;
 	PyObject *applications;
+#ifndef UWSGI_PYPY
 	PyObject *uwsgi_dict = get_uwsgi_pydict("uwsgi");
+#endif
 
 	char *module = (char *) arg1;
 
@@ -442,8 +508,10 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 		return NULL;
 	}
 
+#ifndef UWSGI_PYPY
 	applications = PyDict_GetItemString(uwsgi_dict, "applications");
 	if (applications && PyDict_Check(applications)) return applications;
+#endif
 
 
 	applications = PyDict_GetItemString(wsgi_dict, "applications");
@@ -614,6 +682,8 @@ PyObject *uwsgi_paste_loader(void *arg1) {
 
 PyObject *uwsgi_eval_loader(void *arg1) {
 
+#ifndef UWSGI_PYPY
+
 	char *code = (char *) arg1;
 
 	PyObject *wsgi_eval_module, *wsgi_eval_callable = NULL;
@@ -669,6 +739,9 @@ PyObject *uwsgi_eval_loader(void *arg1) {
 	}
 
 	return wsgi_eval_callable;
+#else
+	return NULL;
+#endif
 
 }
 

plugins/python/python_plugin.c

@@ -16,7 +16,7 @@ struct option uwsgi_python_options[] = {
 	{"module", required_argument, 0, 'w'},
 	{"wsgi", required_argument, 0, 'w'},
 	{"callable", required_argument, 0, LONG_ARGS_CALLABLE},
-	{"test", required_argument, 0, 'j'},
+	{"test", required_argument, 0, 'J'},
 	{"home", required_argument, 0, 'H'},
 	{"virtualenv", required_argument, 0, 'H'},
 	{"venv", required_argument, 0, 'H'},
@@ -47,8 +47,12 @@ struct option uwsgi_python_options[] = {
 	{"ignore-script-name", no_argument, &up.ignore_script_name, 1},
 	{"pep3333-input", no_argument, &up.pep3333_input, 1},
 	{"reload-os-env", no_argument, &up.reload_os_env, 1},
+#ifndef UWSGI_PYPY
 	{"no-site", no_argument, &Py_NoSiteFlag, 1},
+#endif
 	{"pyshell", no_argument, 0, LONG_ARGS_PYSHELL},
+	{"python", required_argument, 0, LONG_ARGS_PYTHON_RUN},
+	{"py", required_argument, 0, LONG_ARGS_PYTHON_RUN},
 
 	{0, 0, 0, 0},
 };
@@ -100,9 +104,14 @@ PyMethodDef uwsgi_write_method[] = { {"uwsgi_write", py_uwsgi_write, METH_VARARG
 
 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);
+#else
+	uwsgi_log("PyPy version: %s\n", PYPY_VERSION);
+#endif
 
+#ifndef UWSGI_PYPY
 	if (up.home != NULL) {
 #ifdef PYTHREE
 		wchar_t *wpyhome;
@@ -131,9 +140,12 @@ int uwsgi_python_init() {
 #endif
 
 
+	Py_OptimizeFlag = up.optimize;
+
 	Py_Initialize();
 
-	Py_OptimizeFlag = up.optimize;
+
+#endif
 
 	up.wsgi_spitout = PyCFunction_New(uwsgi_spit_method, NULL);
 	up.wsgi_writeout = PyCFunction_New(uwsgi_write_method, NULL);
@@ -156,6 +168,7 @@ int uwsgi_python_init() {
 
 void uwsgi_python_reset_random_seed() {
 
+#ifndef UWSGI_PYPY
 	PyObject *random_module, *random_dict, *random_seed;
 
         // reinitialize the random seed (thanks Jonas Borgström)
@@ -175,6 +188,7 @@ void uwsgi_python_reset_random_seed() {
                         }
                 }
         }
+#endif
 }
 
 void uwsgi_python_post_fork() {
@@ -189,6 +203,7 @@ void uwsgi_python_post_fork() {
 
 	uwsgi_python_reset_random_seed();
 
+#ifndef UWSGI_PYPY
 #ifdef UWSGI_EMBEDDED
 	// call the post_fork_hook
 	PyObject *uwsgi_dict = get_uwsgi_pydict("uwsgi");
@@ -200,6 +215,7 @@ void uwsgi_python_post_fork() {
 	}
 	PyErr_Clear();
 #endif
+#endif
 
 UWSGI_RELEASE_GIL
 
@@ -207,6 +223,7 @@ UWSGI_RELEASE_GIL
 
 PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 
+#ifndef UWSGI_PYPY
 	FILE *pyfile;
 	struct _node *py_file_node = NULL;
 	PyObject *py_compiled_node, *py_file_module;
@@ -215,7 +232,7 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	char *real_filename = filename;
 
 
-	if (strncmp(filename, "http://", 7) && strncmp(filename, "sym://", 6) && strncmp(filename, "data://", 7)) {
+	if (!uwsgi_check_scheme(filename)) {
 
 		pyfile = fopen(filename, "r");
 		if (!pyfile) {
@@ -292,10 +309,12 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	}
 
 	return py_file_module;
+#else
+	return NULL;
+#endif
 
 }
 
-
 void init_uwsgi_vars() {
 
 	int i;
@@ -304,11 +323,6 @@ void init_uwsgi_vars() {
 	PyObject *modules = PyImport_GetModuleDict();
 	PyObject *tmp_module;
 
-#ifdef UWSGI_MINTERPRETERS
-	char venv_version[15];
-	PyObject *site_module;
-#endif
-
 	/* add cwd to pythonpath */
 	pysys = PyImport_ImportModule("sys");
 	if (!pysys) {
@@ -331,39 +345,6 @@ void init_uwsgi_vars() {
 		exit(1);
 	}
 
-#ifdef UWSGI_MINTERPRETERS
-	// simulate a pythonhome directive
-	if (uwsgi.wsgi_req->pyhome_len > 0) {
-
-		PyObject *venv_path = UWSGI_PYFROMSTRINGSIZE(uwsgi.wsgi_req->pyhome, uwsgi.wsgi_req->pyhome_len);
-
-#ifdef UWSGI_DEBUG
-		uwsgi_debug("setting dynamic virtualenv to %.*s\n", uwsgi.wsgi_req->pyhome_len, uwsgi.wsgi_req->pyhome);
-#endif
-
-		PyDict_SetItemString(pysys_dict, "prefix", venv_path);
-		PyDict_SetItemString(pysys_dict, "exec_prefix", venv_path);
-
-		venv_version[14] = 0;
-		if (snprintf(venv_version, 15, "/lib/python%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION) == -1) {
-			return;
-		}
-
-		// check here
-		PyString_Concat(&venv_path, PyString_FromString(venv_version));
-
-		if (PyList_Insert(pypath, 0, venv_path)) {
-			PyErr_Print();
-		}
-
-		site_module = PyImport_ImportModule("site");
-		if (site_module) {
-			PyImport_ReloadModule(site_module);
-		}
-
-	}
-#endif
-
 	if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(".")) != 0) {
 		PyErr_Print();
 	}
@@ -549,7 +530,12 @@ void init_uwsgi_embedded_module() {
 		if (PyDict_Contains(py_opt_dict, PyString_FromString(uwsgi.exported_opts[i]->key))) {
 			PyObject *py_opt_item = PyDict_GetItemString(py_opt_dict, uwsgi.exported_opts[i]->key);
 			if (PyList_Check(py_opt_item)) {
-				PyList_Append(py_opt_item, PyString_FromString(uwsgi.exported_opts[i]->value));
+				if (uwsgi.exported_opts[i]->value == NULL) {
+					PyList_Append(py_opt_item, Py_True);
+				}
+				else {
+					PyList_Append(py_opt_item, PyString_FromString(uwsgi.exported_opts[i]->value));
+				}
 			}
 			else {
 				PyObject *py_opt_list = PyList_New(0);
@@ -753,7 +739,6 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 	case LONG_ARGS_PYSHELL:
 		uwsgi.honour_stdin = 1;
 		up.pyshell = 1;
-		uwsgi.to_hell = 1;
 		return 1;
 	case LONG_ARGS_PYIMPORT:
 		uwsgi_string_new_list(&up.import_list, optarg);
@@ -777,7 +762,7 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 	case LONG_ARGS_PYARGV:
 		up.argv = optarg;
 		return 1;
-	case 'j':
+	case 'J':
 		up.test_module = optarg;
 		return 1;
 	case 'H':
@@ -822,14 +807,31 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 	return 0;
 }
 
-int uwsgi_python_mount_app(char *mountpoint, char *app) {
+int uwsgi_python_mount_app(char *mountpoint, char *app, int regexp) {
 
+	int id;
 	uwsgi.wsgi_req->appid = mountpoint;
 	uwsgi.wsgi_req->appid_len = strlen(mountpoint);
 	if (uwsgi.single_interpreter) {
-		return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
+		id = init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 	}
-	return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
+	id = init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
+
+#ifdef UWSGI_PCRE
+	int i;
+	if (regexp && id != -1) {
+		struct uwsgi_app *ua = &uwsgi_apps[id];
+		uwsgi_regexp_build(mountpoint, &ua->pattern, &ua->pattern_extra);
+		if (uwsgi.mywid == 0) {
+			for(i=1;i<=uwsgi.numproc;i++) {
+				uwsgi.workers[i].apps[id].pattern = ua->pattern;
+				uwsgi.workers[i].apps[id].pattern_extra = ua->pattern_extra;
+			}
+		}
+	}
+#endif
+
+	return id;
 
 }
 
@@ -898,19 +900,26 @@ void uwsgi_python_init_apps() {
 
 	if (uwsgi.async > 1) {
 		up.current_recursion_depth = uwsgi_malloc(sizeof(int)*uwsgi.async);
+#ifndef UWSGI_PYPY
         	up.current_frame = uwsgi_malloc(sizeof(struct _frame)*uwsgi.async);
+#endif
 	}
 
 	init_pyargv();
 
-#ifdef UWSGI_MINTERPRETERS
+#ifndef UWSGI_PYPY
+#ifdef UWSGI_EMBEDDED
         init_uwsgi_embedded_module();
 #endif
+#endif
+
 
 #ifdef __linux__
-#ifndef PYTHREE
+#ifndef UWSGI_PYPY
+#ifdef UWSGI_EMBEDDED
 	uwsgi_init_symbol_import();
 #endif
+#endif
 #endif
 
         if (up.test_module != NULL) {
@@ -1013,9 +1022,11 @@ void uwsgi_python_init_apps() {
 	}
 
 	if (uwsgi.profiler) {
+#ifndef UWSGI_PYPY
 		if (!strcmp(uwsgi.profiler, "pycall")) {
 			PyEval_SetProfile(uwsgi_python_profiler_call, NULL);
 		}
+#endif
 	}
 
 }
@@ -1066,7 +1077,9 @@ void uwsgi_python_enable_threads() {
 		up.swap_ts = threaded_swap_ts;
 		up.reset_ts = threaded_reset_ts;
 	}
+
 	uwsgi_log("threads support enabled\n");
+	
 
 }
 
@@ -1077,6 +1090,9 @@ void uwsgi_python_init_thread(int core_id) {
 	pts = PyThreadState_New(up.main_thread->interp);
 	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);
+#endif
 
 }
 
@@ -1130,6 +1146,7 @@ int uwsgi_python_xml(char *node, char *content) {
 	return 0;
 }
 
+#ifndef UWSGI_PYPY
 void uwsgi_python_suspend(struct wsgi_request *wsgi_req) {
 
 	PyThreadState *tstate = PyThreadState_GET();
@@ -1144,6 +1161,7 @@ void uwsgi_python_suspend(struct wsgi_request *wsgi_req) {
 	}
 
 }
+#endif
 
 char *uwsgi_python_code_string(char *id, char *code, char *function, char *key, uint16_t keylen) {
 
@@ -1225,6 +1243,8 @@ clear:
 
 uint16_t uwsgi_python_rpc(void *func, uint8_t argc, char **argv, char *buffer) {
 
+	UWSGI_GET_GIL;
+
 	uint8_t i;
 	PyObject *pyargs = PyTuple_New(argc);
 	PyObject *ret;
@@ -1247,6 +1267,7 @@ uint16_t uwsgi_python_rpc(void *func, uint8_t argc, char **argv, char *buffer) {
 			if (rl <= 0xffff) {
 				memcpy(buffer, rv, rl);
 				Py_DECREF(ret);
+				UWSGI_RELEASE_GIL;
 				return rl;
 			}
 		}
@@ -1255,6 +1276,7 @@ uint16_t uwsgi_python_rpc(void *func, uint8_t argc, char **argv, char *buffer) {
 	if (PyErr_Occurred())
 		PyErr_Print();
 
+	UWSGI_RELEASE_GIL;
 
 	return 0;
 
@@ -1332,6 +1354,7 @@ int uwsgi_python_spooler(char *filename, char *buf, uint16_t len, char *body, si
 	return -1;
 }
 
+#ifndef UWSGI_PYPY
 void uwsgi_python_resume(struct wsgi_request *wsgi_req) {
 
 	PyThreadState *tstate = PyThreadState_GET();
@@ -1346,21 +1369,77 @@ void uwsgi_python_resume(struct wsgi_request *wsgi_req) {
 	}
 
 }
+#endif
 
 void uwsgi_python_fixup() {
 	// set hacky modifier 30
-	uwsgi.p[30] = uwsgi.p[0];
+	uwsgi.p[30] = uwsgi_malloc( sizeof(struct uwsgi_plugin) );
+	memcpy(uwsgi.p[30], uwsgi.p[0], sizeof(struct uwsgi_plugin) );
+	uwsgi.p[30]->init_thread = NULL;
 }
 
 void uwsgi_python_hijack(void) {
 	// the pyshell will be execute only in the first worker
 
+#ifndef UWSGI_PYPY
 	if (up.pyshell && uwsgi.mywid == 1) {
+		// re-map stdin to stdout and stderr if we are logging to a file
+		if (uwsgi.logfile) {
+			if (dup2(0, 1) < 0) {
+				uwsgi_error("dup2()");
+			}
+			if (dup2(0, 2) < 0) {
+				uwsgi_error("dup2()");
+			}
+		}
 		UWSGI_GET_GIL;
 		PyImport_ImportModule("readline");
 		PyRun_InteractiveLoop(stdin, "uwsgi");
 		exit(0);
 	}
+#endif
+}
+
+int uwsgi_python_mule(char *opt) {
+
+	if (uwsgi_endswith(opt, ".py")) {
+		UWSGI_GET_GIL;
+		if (uwsgi_pyimport_by_filename("__main__", opt) == NULL) {
+			return 0;
+		}
+		UWSGI_RELEASE_GIL;
+		return 1;
+	}
+	
+	return 0;
+	
+}
+
+int uwsgi_python_mule_msg(char *message, size_t len) {
+
+	UWSGI_GET_GIL;
+
+	PyObject *mule_msg_hook = PyDict_GetItemString(up.embedded_dict, "mule_msg_hook");
+        if (!mule_msg_hook) {
+                // ignore
+                UWSGI_RELEASE_GIL;
+                return 0;
+        }
+
+	PyObject *pyargs = PyTuple_New(1);
+        PyTuple_SetItem(pyargs, 0, PyString_FromStringAndSize(message, len));
+
+        PyObject *ret = python_call(mule_msg_hook, pyargs, 0, NULL);
+	Py_DECREF(pyargs);
+	if (ret) {
+		Py_DECREF(ret);
+	}
+
+	if (PyErr_Occurred())
+                PyErr_Print();
+
+	UWSGI_RELEASE_GIL;
+	return 1;
 }
 
 struct uwsgi_plugin python_plugin = {
@@ -1372,7 +1451,7 @@ struct uwsgi_plugin python_plugin = {
 	.post_fork = uwsgi_python_post_fork,
 	.options = uwsgi_python_options,
 	.manage_opt = uwsgi_python_manage_options,
-	.short_options = "w:O:H:j:",
+	.short_options = "w:O:H:J:",
 	.request = uwsgi_request_wsgi,
 	.after_request = uwsgi_after_request_wsgi,
 	.init_apps = uwsgi_python_init_apps,
@@ -1388,8 +1467,10 @@ struct uwsgi_plugin python_plugin = {
 
 	.magic = uwsgi_python_magic,
 
+#ifndef UWSGI_PYPY
 	.suspend = uwsgi_python_suspend,
 	.resume = uwsgi_python_resume,
+#endif
 
 	.hijack_worker = uwsgi_python_hijack,
 	.spooler_init = uwsgi_python_spooler_init,
@@ -1397,6 +1478,9 @@ struct uwsgi_plugin python_plugin = {
 	.signal_handler = uwsgi_python_signal_handler,
 	.rpc = uwsgi_python_rpc,
 
+	.mule = uwsgi_python_mule,
+	.mule_msg = uwsgi_python_mule_msg,
+
 	.spooler = uwsgi_python_spooler,
 
 	.code_string = uwsgi_python_code_string,

plugins/python/pyutils.c

@@ -105,7 +105,9 @@ void init_pyargv() {
 			}
 		}
 
+#ifndef UWSGI_PYPY
 		PySys_SetArgv(up.argc, up.py_argv);
+#endif
 
 	PyObject *sys_dict = get_uwsgi_pydict("sys");
 	if (!sys_dict) {

plugins/python/symimporter.c

@@ -1,6 +1,6 @@
 #include "uwsgi_python.h"
 
-#ifndef PYTHREE
+#ifndef UWSGI_PYPY
 
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
@@ -201,9 +201,14 @@ static PyObject* symzipimporter_load_module(PyObject *self, PyObject *args) {
 		PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
                 free(filename);
                 PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+		if (!code) {
+			PyErr_Print();
+			goto shit;
+		}
                 mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
 
                 Py_DECREF(code);
+shit:
                 Py_DECREF(source);
                 free(modname);
                 return mod;
@@ -231,9 +236,14 @@ static PyObject* symzipimporter_load_module(PyObject *self, PyObject *args) {
                 PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
                 free(filename);
                 PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+		if (!code) {
+			PyErr_Print();
+			goto shit2;
+		}
                 mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
 
                 Py_DECREF(code);
+shit2:
                 Py_DECREF(source);
                 free(modname);
                 return mod;
@@ -306,9 +316,14 @@ static PyObject* symimporter_load_module(PyObject *self, PyObject *args) {
 			modname = uwsgi_concat3("sym://", fullname2, "_py");
 
 			code = Py_CompileString(source, modname, Py_file_input);
+		if (!code) {
+			PyErr_Print();
+			goto shit;
+		}
 			mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
 
 			Py_DECREF(code);
+shit:
 			free(source);
 			free(modname);
 			free(fullname2);
@@ -334,9 +349,14 @@ static PyObject* symimporter_load_module(PyObject *self, PyObject *args) {
 			PyDict_SetItemString(dict, "__loader__", self);
 
                         code = Py_CompileString(source, modname, Py_file_input);
+		if (!code) {
+			PyErr_Print();
+			goto shit2;
+		}
                         mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
 
 			Py_DECREF(code);
+shit2:
 			free(source);
 			free(modname);
 			free(fullname2);
@@ -363,7 +383,7 @@ static PyMethodDef symzipimporter_methods[] = {
 };
 
 static void uwsgi_symimporter_free(struct _symimporter *self) {
-        PyObject_Del(self);
+	PyObject_Del(self);
 }
 
 
@@ -406,7 +426,7 @@ static PyTypeObject SymImporter_Type = {
     0,                 /* tp_init */
     PyType_GenericAlloc,                        /* tp_alloc */
     PyType_GenericNew,                          /* tp_new */
-    PyObject_GC_Del,                            /* tp_free */
+    0,                            /* tp_free */
 };
 
 static int
@@ -424,7 +444,7 @@ zipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
         // avoid GC !!!
         name = uwsgi_concat2(name, "");
 
-	if (!uwsgi_startswith(name, "http://", 7) || !uwsgi_startswith(name, "data://", 7) || !uwsgi_startswith(name, "sym://", 6) ) {
+	if (uwsgi_check_scheme(name)) {
                 prefix = uwsgi_get_last_char(name, '/');
                 prefix = uwsgi_get_last_char(prefix, ':');
         }
@@ -442,35 +462,53 @@ zipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
 		return -1;
 	}
 
+
+
 	PyObject *stringio = PyImport_ImportModule("StringIO");
         if (!stringio) {
                 return -1;
         }
 
-        PyObject *stringio_dict = PyModule_GetDict(stringio);
+
+#ifdef PYTHREE
+        PyObject *source_code = PyObject_CallMethodObjArgs(stringio, PyString_FromString("StringIO"), PyString_FromStringAndSize(body, len));
+#else
+	PyObject *stringio_dict = PyModule_GetDict(stringio);
         if (!stringio_dict) {
                 return -1;
         }
 
+
         PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
         if (!stringio_stringio) {
                 return -1;
         }
 
+
         PyObject *stringio_args = PyTuple_New(1);
         PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(body, len));
 
+
+
         PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+#endif
         if (!source_code) {
                 return -1;
         }
 
+
         PyObject *zipfile = PyImport_ImportModule("zipfile");
+
         if (!zipfile) {
+		PyErr_Print();
                 return -1;
         }
 
-        PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+
+#ifdef PYTHREE
+	self->zip = PyObject_CallMethodObjArgs(zipfile, PyString_FromString("ZipFile"), source_code);
+#else
+	PyObject *zipfile_dict = PyModule_GetDict(zipfile);
         if (!zipfile_dict) {
                 return -1;
         }
@@ -480,10 +518,13 @@ zipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
                 return -1;
         }
 
+
         PyObject *zipfile_args = PyTuple_New(1);
         PyTuple_SetItem(zipfile_args, 0, source_code);
 
+
         self->zip = PyInstance_New(zipfile_zipfile, zipfile_args, NULL);
+#endif
         if (!self->zip) {
                 return -1;
         }
@@ -545,6 +586,9 @@ symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds
 		return -1;
 	}
 
+#ifdef PYTHREE
+	PyObject *source_code = PyObject_CallMethodObjArgs(stringio, PyString_FromString("StringIO"), PyString_FromStringAndSize(code_start, code_end-code_start));
+#else
 	PyObject *stringio_dict = PyModule_GetDict(stringio);
 	if (!stringio_dict) {
 		return -1;
@@ -558,7 +602,9 @@ symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds
 	PyObject *stringio_args = PyTuple_New(1);
 	PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(code_start, code_end-code_start));
 
+
 	PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+#endif
 	if (!source_code) {
 		return -1;
 	}
@@ -568,6 +614,9 @@ symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds
 		return -1;
 	}
 	
+#ifdef PYTHREE
+	self->zip = PyObject_CallMethodObjArgs(zipfile, PyString_FromString("ZipFile"), source_code);
+#else
 	PyObject *zipfile_dict = PyModule_GetDict(zipfile);
         if (!zipfile_dict) {
                 return -1;
@@ -581,7 +630,9 @@ symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds
         PyObject *zipfile_args = PyTuple_New(1);
         PyTuple_SetItem(zipfile_args, 0, source_code);
 
+
 	self->zip = PyInstance_New(zipfile_zipfile, zipfile_args, NULL);
+#endif
         if (!self->zip) {
                 return -1;
         }
@@ -644,7 +695,7 @@ static PyTypeObject SymZipImporter_Type = {
     (initproc) symzipimporter_init,                 /* tp_init */
     PyType_GenericAlloc,                        /* tp_alloc */
     PyType_GenericNew,                          /* tp_new */
-    PyObject_GC_Del,                            /* tp_free */
+    0,                            /* tp_free */
 };
 
 static PyTypeObject ZipImporter_Type = {
@@ -686,7 +737,7 @@ static PyTypeObject ZipImporter_Type = {
     (initproc) zipimporter_init,                 /* tp_init */
     PyType_GenericAlloc,                        /* tp_alloc */
     PyType_GenericNew,                          /* tp_new */
-    PyObject_GC_Del,                            /* tp_free */
+    0,                            /* tp_free */
 };
 
 

plugins/python/uwsgi_pymodule.c

@@ -834,7 +834,7 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 
 	PyObject *what;
 	char *filename;
-	size_t chunk;
+	size_t chunk = 0;
 	off_t pos = 0;
 	size_t filesize = 0;
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -890,7 +890,20 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 	wsgi_req->sendfile_fd_pos = pos;
 
 	// do sendfile
-	wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
+	if (uwsgi.async > 1) {
+		ssize_t sf_len = uwsgi_sendfile(wsgi_req);
+		if (sf_len > 0) {
+			wsgi_req->response_size += sf_len;
+			while((size_t)wsgi_req->sendfile_fd_pos < wsgi_req->sendfile_fd_size) {
+				sf_len = uwsgi_sendfile(wsgi_req);
+				if (sf_len <= 0) break;
+				wsgi_req->response_size += sf_len;
+			}
+		}
+	}
+	else {
+		wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
+	}
 
 	// revert to old values
 	wsgi_req->sendfile_fd = tmp_fd;
@@ -982,13 +995,24 @@ PyObject *py_uwsgi_i_am_the_spooler(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_lock(PyObject * self, PyObject * args) {
 
+	int lock_num = 0;
+
 	// the spooler cannot lock resources
 #ifdef UWSGI_SPOOLER
 	if (uwsgi.mypid == uwsgi.shared->spooler_pid) {
 		return PyErr_Format(PyExc_ValueError, "The spooler cannot lock/unlock resources");
 	}
 #endif
-	uwsgi_lock(uwsgi.user_lock);
+
+	if (!PyArg_ParseTuple(args, "|i:lock", &lock_num)) {
+                return NULL;
+        }
+
+	if (lock_num < 0 || lock_num > uwsgi.locks) {
+		return PyErr_Format(PyExc_ValueError, "Invalid lock number");
+	}
+
+	uwsgi_lock(uwsgi.user_lock[lock_num]);
 
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -996,13 +1020,24 @@ PyObject *py_uwsgi_lock(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_unlock(PyObject * self, PyObject * args) {
 
+	int lock_num = 0;
+
 #ifdef UWSGI_SPOOLER
 	if (uwsgi.mypid == uwsgi.shared->spooler_pid) {
 		return PyErr_Format(PyExc_ValueError, "The spooler cannot lock/unlock resources");
 	}
 #endif
 
-	uwsgi_unlock(uwsgi.user_lock);
+	if (!PyArg_ParseTuple(args, "|i:unlock", &lock_num)) {
+                return NULL;
+        }
+
+        if (lock_num < 0 || lock_num > uwsgi.locks) {
+                return PyErr_Format(PyExc_ValueError, "Invalid lock number");
+        }
+
+
+	uwsgi_unlock(uwsgi.user_lock[lock_num]);
 
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -1037,6 +1072,339 @@ PyObject *py_uwsgi_embedded_data(PyObject * self, PyObject * args) {
 
 }
 
+PyObject *py_uwsgi_setprocname(PyObject * self, PyObject * args) {
+	char *name = NULL;
+
+	if (!PyArg_ParseTuple(args, "s:setprocname", &name)) {
+                return NULL;
+        }
+
+	uwsgi_set_processname(name);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *py_uwsgi_in_farm(PyObject * self, PyObject * args) {
+
+	char *farm_name = NULL;
+	int i;
+
+	if (!PyArg_ParseTuple(args, "|s:in_farm", &farm_name)) {
+                return NULL;
+        }
+
+	if (uwsgi.muleid == 0) goto none;
+
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+		if (!farm_name) {
+			if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) {
+				Py_INCREF(Py_True);
+				return Py_True;
+			}
+		}
+		else {
+			if (!strcmp(farm_name, uwsgi.farms[i].name)) {
+				if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) {
+					Py_INCREF(Py_True);
+					return Py_True;
+				}
+			}
+		}
+	}
+none:
+
+	Py_INCREF(Py_None);
+	return Py_None;
+   
+}
+
+PyObject *py_uwsgi_farm_msg(PyObject * self, PyObject * args) {
+
+        char *message = NULL;
+        Py_ssize_t message_len = 0;
+	char *farm_name = NULL;
+        ssize_t len;
+	int i;
+
+        if (!PyArg_ParseTuple(args, "ss#:farm_msg", &farm_name, &message, &message_len)) {
+                return NULL;
+        }
+
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+	
+		if (!strcmp(farm_name, uwsgi.farms[i].name)) {
+                	len = write(uwsgi.farms[i].queue_pipe[0], message, message_len);
+                	if (len <= 0) {
+                        	uwsgi_error("write()");
+                	}
+			break;
+		}
+	
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+
+}
+
+
+PyObject *py_uwsgi_mule_msg(PyObject * self, PyObject * args) {
+
+	char *message = NULL;
+	Py_ssize_t message_len = 0;
+	PyObject *mule_obj = NULL;
+	ssize_t len;
+	int fd = -1;
+	int mule_id = -1;
+
+	if (!PyArg_ParseTuple(args, "s#|O:mule_msg", &message, &message_len, &mule_obj)) {
+                return NULL;
+        }
+
+	if (uwsgi.mules_cnt < 1)
+		return PyErr_Format(PyExc_ValueError, "no mule configured");
+
+	if (mule_obj == NULL) {
+		len = write(uwsgi.shared->mule_queue_pipe[0], message, message_len);
+		if (len <= 0) {
+			uwsgi_error("write()");
+		}
+	}
+	else {
+		if (PyString_Check(mule_obj)) {
+			struct uwsgi_farm *uf = get_farm_by_name(PyString_AsString(mule_obj));
+			if (uf == NULL) {
+				return PyErr_Format(PyExc_ValueError, "unknown farm");
+			}
+			fd = uf->queue_pipe[0];
+		}
+		else if (PyInt_Check(mule_obj)) {
+			mule_id = PyInt_AsLong(mule_obj);
+			if (mule_id < 0 && mule_id > uwsgi.mules_cnt) {
+				return PyErr_Format(PyExc_ValueError, "invalid mule number");
+			}
+			if (mule_id == 0) {
+				fd = uwsgi.shared->mule_queue_pipe[0];
+			}
+			else {
+				fd = uwsgi.mules[mule_id-1].queue_pipe[0];
+			}
+		}
+		else {
+			return PyErr_Format(PyExc_ValueError, "invalid mule");
+		}
+
+		if (fd > -1) {
+			len = write(fd, message, message_len);
+			if (len < 0) {
+				uwsgi_error("write()");
+			}
+		}
+	}
+
+	Py_INCREF(Py_None);
+	return Py_None;
+	
+}
+
+PyObject *py_uwsgi_mule_get_msg(PyObject * self, PyObject * args, PyObject *kwargs) {
+
+	ssize_t len = 0;
+	// this buffer will be configurable
+	char *message;
+	struct pollfd *mulepoll;
+	int count = 4;
+	int farms_count = 0;
+	uint8_t uwsgi_signal;
+	PyObject *manage_signals = NULL;
+	PyObject *manage_farms = NULL;
+	int buffer_size = 65536;
+	int timeout = -1;
+	int i;
+
+	static char *kwlist[] = {"signals", "buffer_size", "timeout", "farms", NULL};
+
+	if (uwsgi.muleid == 0) {
+		return PyErr_Format(PyExc_ValueError, "you can receive mule messages only in a mule !!!");
+	}
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii:mule_get_msg", kwlist, &manage_signals, &manage_farms, &buffer_size, &timeout)) {
+		return NULL;
+	}
+
+	if (manage_signals == Py_None || manage_signals == Py_False) {
+		count = 2;
+	}
+
+	if (manage_farms == Py_None || manage_farms == Py_False) {
+		goto next;
+	}
+	
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+        	if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) farms_count++;
+        }
+
+
+next:
+
+	UWSGI_RELEASE_GIL;
+	if (timeout > -1) timeout = timeout*1000;
+
+	message = uwsgi_malloc(buffer_size);
+	mulepoll = uwsgi_malloc(sizeof(struct pollfd) * (count+farms_count));
+
+	mulepoll[0].fd = uwsgi.mules[uwsgi.muleid-1].queue_pipe[1];
+	mulepoll[0].events = POLLIN;
+	mulepoll[1].fd = uwsgi.shared->mule_queue_pipe[1];
+	mulepoll[1].events = POLLIN;
+	if (count > 2) {
+		mulepoll[2].fd = uwsgi.signal_socket;
+		mulepoll[2].events = POLLIN;
+		mulepoll[3].fd = uwsgi.my_signal_socket;
+		mulepoll[3].events = POLLIN;
+	}
+
+	for(i=0;i<farms_count;i++) {
+		mulepoll[count+i].fd = uwsgi.farms[i].queue_pipe[1];
+		mulepoll[count+i].events = POLLIN;
+	}
+
+	int ret = poll(mulepoll, count+farms_count, timeout);
+	if (ret <= 0) {
+		uwsgi_error("poll");
+	}
+	else {
+		if (mulepoll[0].revents & POLLIN) {
+			len = read(uwsgi.mules[uwsgi.muleid-1].queue_pipe[1], message, buffer_size);
+		}
+		else if (mulepoll[1].revents & POLLIN) {
+			len = read(uwsgi.shared->mule_queue_pipe[1], message, buffer_size);
+		}
+		else {
+			if (count > 2) {
+				int interesting_fd = -1;
+				if (mulepoll[2].revents & POLLIN) {
+					interesting_fd = mulepoll[2].fd;
+				}
+				else if (mulepoll[3].revents & POLLIN) {
+                                	interesting_fd = mulepoll[3].fd;
+                        	}
+	
+				if (interesting_fd > -1) {
+					len = read(interesting_fd, &uwsgi_signal, 1);
+                        		if (len <= 0) {
+                                		uwsgi_log_verbose("uWSGI mule %d braying: my master died, i will follow him...\n", uwsgi.muleid);
+                                		end_me(0);
+                        		}
+#ifdef UWSGI_DEBUG
+                        		uwsgi_log_verbose("master sent signal %d to mule %d\n", uwsgi_signal, uwsgi.muleid);
+#endif
+                        		if (uwsgi_signal_handler(uwsgi_signal)) {
+                                		uwsgi_log_verbose("error managing signal %d on mule %d\n", uwsgi_signal, uwsgi.mywid);
+                        		}
+					goto clear;
+				}
+			}
+
+			for(i=0;i<farms_count;i++) {
+				if (mulepoll[count+i].revents & POLLIN) {
+					len = read(mulepoll[count+i].fd, message, buffer_size);
+					break;
+				}
+			}
+		}
+	}
+	UWSGI_GET_GIL;
+	if (len < 0) {
+		uwsgi_error("read()");
+		goto clear2;
+	}
+
+	PyObject *msg = PyString_FromStringAndSize(message, len);
+	free(message);
+	free(mulepoll);
+	return msg;
+clear:
+	UWSGI_GET_GIL;
+clear2:
+	free(message);
+	free(mulepoll);
+	Py_INCREF(Py_None);
+        return Py_None;
+}
+
+PyObject *py_uwsgi_farm_get_msg(PyObject * self, PyObject * args) {
+
+        ssize_t len = 0;
+        // this buffer will be configurable
+        char message[65536];
+	int i, count = 0, pos = 0, ret;
+	struct pollfd *farmpoll;
+
+        if (uwsgi.muleid == 0) {
+                return PyErr_Format(PyExc_ValueError, "you can receive farm messages only in a mule !!!");
+        }
+        UWSGI_RELEASE_GIL;
+	for(i=0;i<uwsgi.farms_cnt;i++) {	
+		if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) count++;
+	}
+	farmpoll = uwsgi_malloc( sizeof(struct pollfd) * count);
+	for(i=0;i<uwsgi.farms_cnt;i++) {
+		if (uwsgi_farm_has_mule(&uwsgi.farms[i], uwsgi.muleid)) {
+			farmpoll[pos].fd = uwsgi.farms[i].queue_pipe[1];
+			farmpoll[pos].events = POLLIN;
+			pos++;
+		}
+	}
+
+	ret = poll(farmpoll, count, -1);
+	if (ret <= 0) {
+		uwsgi_error("poll()");
+		free(farmpoll);
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	for(i=0;i<count;i++) {
+		if (farmpoll[i].revents & POLLIN) {
+        		len = read(farmpoll[i].fd, message, 65536);
+			break;
+		}
+	}
+        UWSGI_GET_GIL;
+        if (len <= 0) {
+                uwsgi_error("read()");
+		free(farmpoll);
+                Py_INCREF(Py_None);
+                return Py_None;
+        }
+
+	free(farmpoll);
+        return PyString_FromStringAndSize(message, len);
+}
+
+
+PyObject *py_uwsgi_extract(PyObject * self, PyObject * args) {
+
+        char *name;
+	int len;
+	char *buf;
+
+        if (!PyArg_ParseTuple(args, "s:extract", &name)) {
+                return NULL;
+        }
+
+	buf = uwsgi_open_and_read(name, &len, 0, NULL);
+	if (buf && len > 0) {
+        	return PyString_FromStringAndSize(buf, len);
+	}
+	Py_INCREF(Py_None);
+	return Py_None;
+
+}
+
+
 PyObject *py_uwsgi_sharedarea_inclong(PyObject * self, PyObject * args) {
 	uint64_t pos = 0;
 	uint64_t value = 1;
@@ -1499,7 +1867,6 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 
 	PyObject *arg_modifier1, *arg_modifier2, *arg_timeout;
 
-	PyObject *marshalled;
 	PyObject *retobject;
 
 
@@ -1568,6 +1935,8 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 		}
 
 
+#ifndef UWSGI_PYPY
+	PyObject *marshalled;
 		switch (PyInt_AsLong(arg_modifier1)) {
 		case UWSGI_MODIFIER_MESSAGE_MARSHAL:
 			marshalled = PyMarshal_WriteObjectToString(arg_message, 1);
@@ -1582,6 +1951,7 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 			}
 			break;
 		}
+#endif
 
 
 	}
@@ -1909,7 +2279,7 @@ PyObject *py_uwsgi_async_connect(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 
-	PyObject *pyobj = NULL, *marshalled = NULL;
+	PyObject *pyobj = NULL;
 
 	int uwsgi_fd;
 	int modifier1 = 0;
@@ -1938,8 +2308,9 @@ PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 		esize = PyString_Size(pyobj);
 		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
 	}
+#ifndef UWSGI_PYPY
 	else {
-		marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
+		PyObject *marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
 		if (!marshalled) {
 			PyErr_Print();
 			goto clear;
@@ -1949,6 +2320,7 @@ PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 		esize = PyString_Size(marshalled);
 		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
 	}
+#endif
 
       UWSGI_GET_GIL clear:
 
@@ -2049,7 +2421,7 @@ PyObject *py_uwsgi_fcgi(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 
-	PyObject *destination = NULL, *pyobj = NULL, *marshalled = NULL;
+	PyObject *destination = NULL, *pyobj = NULL;
 
 	int modifier1 = 0;
 	int modifier2 = 0;
@@ -2094,8 +2466,9 @@ PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 		esize = PyString_Size(pyobj);
 		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
 	}
+#ifndef UWSGI_PYPY
 	else {
-		marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
+		PyObject *marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
 		if (!marshalled) {
 			PyErr_Print();
 			goto clear;
@@ -2105,6 +2478,7 @@ PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 		esize = PyString_Size(marshalled);
 		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
 	}
+#endif
 
 	UWSGI_GET_GIL
 
@@ -2151,7 +2525,7 @@ PyObject *py_uwsgi_masterpid(PyObject * self, PyObject * args) {
 
 	/* uWSGI total_requests */
 PyObject *py_uwsgi_total_requests(PyObject * self, PyObject * args) {
-	return PyInt_FromLong(uwsgi.workers[0].requests);
+	return PyLong_FromUnsignedLongLong(uwsgi.workers[0].requests);
 }
 
 	/* uWSGI workers */
@@ -2181,31 +2555,57 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 		}
 		Py_DECREF(zero);
 
-		zero = PyInt_FromLong(uwsgi.workers[i + 1].requests);
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].requests);
 		if (PyDict_SetItemString(worker_dict, "requests", zero)) {
 			goto clear;
 		}
 		Py_DECREF(zero);
 
-		zero = PyInt_FromLong(uwsgi.workers[i + 1].exceptions);
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].signals);
+		if (PyDict_SetItemString(worker_dict, "signals", zero)) {
+			goto clear;
+		}
+		Py_DECREF(zero);
+
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].exceptions);
 		if (PyDict_SetItemString(worker_dict, "exceptions", zero)) {
 			goto clear;
 		}
 		Py_DECREF(zero);
 
-		zero = PyInt_FromLong(uwsgi.workers[i + 1].rss_size);
+		if (uwsgi.workers[i + 1].cheaped) {
+			zero = PyString_FromString("cheap");
+		}
+		else {
+			if (uwsgi.workers[i + 1].sig) {
+				zero = PyString_FromFormat("sig%d",uwsgi.workers[i + 1].signum);
+			}
+			else if (uwsgi.workers[i + 1].busy) {
+				zero = PyString_FromString("busy");
+			}
+			else {
+				zero = PyString_FromString("idle");
+			}
+		}
+		if (PyDict_SetItemString(worker_dict, "status", zero)) {
+                        goto clear;
+                }
+
+		Py_DECREF(zero);
+
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].rss_size);
 		if (PyDict_SetItemString(worker_dict, "rss", zero)) {
 			goto clear;
 		}
 		Py_DECREF(zero);
 
-		zero = PyInt_FromLong(uwsgi.workers[i + 1].vsz_size);
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].vsz_size);
 		if (PyDict_SetItemString(worker_dict, "vsz", zero)) {
 			goto clear;
 		}
 		Py_DECREF(zero);
 
-		zero = PyFloat_FromDouble(uwsgi.workers[i + 1].running_time);
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].running_time);
 		if (PyDict_SetItemString(worker_dict, "running_time", zero)) {
 			goto clear;
 		}
@@ -2217,20 +2617,23 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 		}
 		Py_DECREF(zero);
 
-		zero = PyLong_FromLong(uwsgi.workers[i + 1].respawn_count);
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].respawn_count-1);
 		if (PyDict_SetItemString(worker_dict, "respawn_count", zero)) {
 			goto clear;
 		}
 		Py_DECREF(zero);
 
-		/* return a tuple of current status ! (in_request, blocking, locking, )
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].tx);
+		if (PyDict_SetItemString(worker_dict, "tx", zero)) {
+			goto clear;
+		}
+		Py_DECREF(zero);
 
-		   zero = PyLong_FromLong(uwsgi.workers[i+1].in_request);
-		   if (PyDict_SetItemString(worker_dict, "in_request", zero)) {
-		   goto clear;
-		   }
-		   Py_DECREF(zero);
-		 */
+		zero = PyLong_FromUnsignedLongLong(uwsgi.workers[i + 1].avg_response_time);
+		if (PyDict_SetItemString(worker_dict, "avg_rt", zero)) {
+			goto clear;
+		}
+		Py_DECREF(zero);
 
 		apps_tuple = PyTuple_New(uwsgi.workers[i+1].apps_cnt);
 
@@ -2249,8 +2652,8 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 			PyDict_SetItemString(apps_dict, "interpreter", PyInt_FromLong((long)ua->interpreter));
 			PyDict_SetItemString(apps_dict, "callable", PyInt_FromLong((long)ua->interpreter));
 
-			PyDict_SetItemString(apps_dict, "requests", PyInt_FromLong(ua->requests));
-			PyDict_SetItemString(apps_dict, "exceptions", PyInt_FromLong(ua->exceptions));
+			PyDict_SetItemString(apps_dict, "requests", PyLong_FromUnsignedLongLong(ua->requests));
+			PyDict_SetItemString(apps_dict, "exceptions", PyLong_FromUnsignedLongLong(ua->exceptions));
 
 			if (ua->chdir) {
 				zero = PyString_FromString(ua->chdir);
@@ -2297,6 +2700,20 @@ PyObject *py_uwsgi_reload(PyObject * self, PyObject * args) {
 	return Py_True;
 }
 
+/* uWSGI stop */
+PyObject *py_uwsgi_stop(PyObject * self, PyObject * args) {
+
+        if (kill(uwsgi.workers[0].pid, SIGQUIT)) {
+                uwsgi_error("kill()");
+                Py_INCREF(Py_None);
+                return Py_None;
+        }
+
+        Py_INCREF(Py_True);
+        return Py_True;
+}
+
+
 	/* blocking hint */
 PyObject *py_uwsgi_set_blocking(PyObject * self, PyObject * args) {
 
@@ -2312,25 +2729,30 @@ PyObject *py_uwsgi_set_blocking(PyObject * self, PyObject * args) {
 
 
 PyObject *py_uwsgi_request_id(PyObject * self, PyObject * args) {
-	return PyInt_FromLong(uwsgi.workers[uwsgi.mywid].requests);
+	return PyLong_FromUnsignedLongLong(uwsgi.workers[uwsgi.mywid].requests);
 }
 
 PyObject *py_uwsgi_worker_id(PyObject * self, PyObject * args) {
 	return PyInt_FromLong(uwsgi.mywid);
 }
 
+PyObject *py_uwsgi_mule_id(PyObject * self, PyObject * args) {
+	return PyInt_FromLong(uwsgi.muleid);
+}
+
 PyObject *py_uwsgi_logsize(PyObject * self, PyObject * args) {
-	return PyInt_FromLong(uwsgi.shared->logsize);
+	return PyLong_FromUnsignedLongLong(uwsgi.shared->logsize);
 }
 
 PyObject *py_uwsgi_mem(PyObject * self, PyObject * args) {
 
+	uint64_t rss=0, vsz = 0;
 	PyObject *ml = PyTuple_New(2);
 
-	get_memusage();
+	get_memusage(&rss, &vsz);
 
-	PyTuple_SetItem(ml, 0, PyLong_FromLong(uwsgi.workers[uwsgi.mywid].rss_size));
-	PyTuple_SetItem(ml, 1, PyLong_FromLong(uwsgi.workers[uwsgi.mywid].vsz_size));
+	PyTuple_SetItem(ml, 0, PyLong_FromUnsignedLongLong(rss));
+	PyTuple_SetItem(ml, 1, PyLong_FromUnsignedLongLong(vsz));
 
 	return ml;
 
@@ -2340,7 +2762,7 @@ PyObject *py_uwsgi_cl(PyObject * self, PyObject * args) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 
-	return PyLong_FromLong(wsgi_req->post_cl);
+	return PyLong_FromUnsignedLongLong(wsgi_req->post_cl);
 
 }
 
@@ -2482,6 +2904,7 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 		goto clear;
 	}
 
+	// use a normal fork here
 	grunt_pid = fork();
 	if (grunt_pid < 0) {
 		uwsgi_error("fork()");
@@ -2634,6 +3057,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"send_message", py_uwsgi_send_message, METH_VARARGS, ""},
 	{"send_multi_message", py_uwsgi_send_multi_message, METH_VARARGS, ""},
 	{"reload", py_uwsgi_reload, METH_VARARGS, ""},
+	{"stop", py_uwsgi_stop, METH_VARARGS, ""},
 	{"workers", py_uwsgi_workers, METH_VARARGS, ""},
 	{"masterpid", py_uwsgi_masterpid, METH_VARARGS, ""},
 	{"total_requests", py_uwsgi_total_requests, METH_VARARGS, ""},
@@ -2644,6 +3068,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"sorry_i_need_to_block", py_uwsgi_set_blocking, METH_VARARGS, ""},
 	{"request_id", py_uwsgi_request_id, METH_VARARGS, ""},
 	{"worker_id", py_uwsgi_worker_id, METH_VARARGS, ""},
+	{"mule_id", py_uwsgi_mule_id, METH_VARARGS, ""},
 	{"log", py_uwsgi_log, METH_VARARGS, ""},
 	{"log_this_request", py_uwsgi_log_this, METH_VARARGS, ""},
 	{"disconnect", py_uwsgi_disconnect, METH_VARARGS, ""},
@@ -2653,6 +3078,8 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"unlock", py_uwsgi_unlock, METH_VARARGS, ""},
 	{"cl", py_uwsgi_cl, METH_VARARGS, ""},
 
+	{"setprocname", py_uwsgi_setprocname, METH_VARARGS, ""},
+
 	{"listen_queue", py_uwsgi_listen_queue, METH_VARARGS, ""},
 
 	{"attach_daemon", py_uwsgi_attach_daemon, METH_VARARGS, ""},
@@ -2709,6 +3136,13 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 
 	{"parsefile", py_uwsgi_parse_file, METH_VARARGS, ""},
 	{"embedded_data", py_uwsgi_embedded_data, METH_VARARGS, ""},
+	{"extract", py_uwsgi_extract, METH_VARARGS, ""},
+
+	{"mule_msg", py_uwsgi_mule_msg, METH_VARARGS, ""},
+	{"farm_msg", py_uwsgi_farm_msg, METH_VARARGS, ""},
+	{"mule_get_msg", (PyCFunction) py_uwsgi_mule_get_msg, METH_VARARGS|METH_KEYWORDS, ""},
+	{"farm_get_msg", py_uwsgi_farm_get_msg, METH_VARARGS, ""},
+	{"in_farm", py_uwsgi_in_farm, METH_VARARGS, ""},
 	//{"call_hook", py_uwsgi_call_hook, METH_VARARGS, ""},
 
 	{NULL, NULL},
@@ -2922,12 +3356,12 @@ PyObject *py_uwsgi_queue_set(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_queue_slot(PyObject * self, PyObject * args) {
 
-	return PyInt_FromLong(uwsgi.queue_header->pos);
+	return PyLong_FromUnsignedLongLong(uwsgi.queue_header->pos);
 }
 
 PyObject *py_uwsgi_queue_pull_slot(PyObject * self, PyObject * args) {
 
-	return PyInt_FromLong(uwsgi.queue_header->pull_pos);
+	return PyLong_FromUnsignedLongLong(uwsgi.queue_header->pull_pos);
 }
 
 
@@ -3016,23 +3450,44 @@ PyObject *py_uwsgi_queue_last(PyObject * self, PyObject * args) {
         long num = 0;
         uint64_t size = 0;
         char *message;
-        PyObject *res, *zero;
+        PyObject *res = NULL, *zero;
 	uint64_t base;
 
-        if (!PyArg_ParseTuple(args, "l:queue_last", &num)) {
+        if (!PyArg_ParseTuple(args, "|l:queue_last", &num)) {
                 return NULL;
         }
 
         if (uwsgi.queue_size) {
-		res = PyList_New(0);
+
+		if (num > 0) {
+			res = PyList_New(0);
+		}
+
                 uwsgi_rlock(uwsgi.queue_lock);
+
 		if (uwsgi.queue_header->pos > 0) {
 			base = uwsgi.queue_header->pos-1;
 		}
 		else {
 			base = uwsgi.queue_size-1;
 		}
+
+		if (num == 0) {
+                	message = uwsgi_queue_get(base, &size);
+                	if (message && size) {
+                        	res = PyString_FromStringAndSize(message, size);
+                	}
+                	else {
+				Py_INCREF(Py_None);
+				res = Py_None;
+                	}
+
+                	uwsgi_rwunlock(uwsgi.queue_lock);
+			return res;
+		}
+
 		if (num > (long)uwsgi.queue_size) num = uwsgi.queue_size;
+
 		while(num) {
                 	message = uwsgi_queue_get(base, &size);
                 	if (message && size) {
@@ -3084,6 +3539,7 @@ PyObject *py_uwsgi_cache_get(PyObject * self, PyObject * args) {
 		uwsgi_simple_message_string(remote, 111, 0, key, keylen, buffer, &valsize16, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
 		if (valsize16 > 0) {
 			value = buffer;
+			valsize = valsize16;
 		}
 	}
 	else if (uwsgi.cache_max_items) {
@@ -3216,7 +3672,7 @@ void init_uwsgi_module_queue(PyObject * current_uwsgi_module) {
                 Py_DECREF(func);
         }
 
-	PyDict_SetItemString(uwsgi_module_dict, "queue_size", PyInt_FromLong(uwsgi.queue_size));
+	PyDict_SetItemString(uwsgi_module_dict, "queue_size", PyLong_FromUnsignedLongLong(uwsgi.queue_size));
 }
 
 

plugins/python/uwsgi_python.h

@@ -20,6 +20,7 @@
 #define LONG_ARGS_WSGI_LITE		LONG_ARGS_PYTHON_BASE + 10
 #define LONG_ARGS_PYSHELL		LONG_ARGS_PYTHON_BASE + 11
 #define LONG_ARGS_SPOOLER_PYIMPORT	LONG_ARGS_PYTHON_BASE + 12
+#define LONG_ARGS_PYTHON_RUN		LONG_ARGS_PYTHON_BASE + 13
 
 #define PYTHON_APP_TYPE_WSGI		0
 #define PYTHON_APP_TYPE_WEB3		1
@@ -29,6 +30,7 @@
 
 #if PY_MINOR_VERSION == 4 && PY_MAJOR_VERSION == 2
 #define Py_ssize_t ssize_t
+#define UWSGI_PYTHON_OLD
 #endif
 
 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 7
@@ -94,9 +96,11 @@ PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t);
 
 #define LOADER_MAX              8
 
+#define UWSGI_PY_READLINE_BUFSIZE 1024
+
 typedef struct uwsgi_Input {
         PyObject_HEAD
-        char readline[1024];
+        char readline[UWSGI_PY_READLINE_BUFSIZE];
         size_t readline_size;
         size_t readline_max_size;
         size_t readline_pos;
@@ -264,10 +268,12 @@ void uwsgi_python_reset_random_seed(void);
 
 char *uwsgi_pythonize(char *);
 
+#ifdef UWSGI_PYPY
+#undef UWSGI_MINTERPRETERS
+#endif
+
 #define uwsgi_pyexit {PyErr_Print();exit(1);}
 
 #ifdef __linux__
-#ifndef PYTHREE
 int uwsgi_init_symbol_import(void);
 #endif
-#endif

plugins/python/uwsgiplugin.py

@@ -4,28 +4,36 @@ from distutils import sysconfig
 
 NAME='python'
 GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter']
+#OBJ_LIST = ['/usr/lib/libpython2.6.a']
 
 CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True) ] 
+
+if 'pypy_version_info' in sys.__dict__:
+    CFLAGS.append('-DUWSGI_PYPY')
+
 LDFLAGS = []
 
-LIBS = sysconfig.get_config_var('LIBS').split() + sysconfig.get_config_var('SYSLIBS').split()
-if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
+if not 'UWSGI_PYTHON_NOLIB' in os.environ:
+    LIBS = sysconfig.get_config_var('LIBS').split() + sysconfig.get_config_var('SYSLIBS').split()
+    if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
         LIBS.append('-L' + sysconfig.get_config_var('LIBPL'))
+    else:
+        try:
+            LDFLAGS.append("-L%s" % sysconfig.get_config_var('LIBDIR'))
+            os.environ['LD_RUN_PATH'] = "%s" % (sysconfig.get_config_var('LIBDIR'))
+        except:
+            LDFLAGS.append("-L%s/lib" % sysconfig.PREFIX)
+            os.environ['LD_RUN_PATH'] = "%s/lib" % sysconfig.PREFIX
+
+
+    version = sysconfig.get_config_var('VERSION')
+    try:
+        version = version + sys.abiflags
+    except:
+        pass
+    LIBS.append('-lpython' + version)
 else:
-	try:
-		LDFLAGS.append("-L%s" % sysconfig.get_config_var('LIBDIR'))
-		os.environ['LD_RUN_PATH'] = "%s" % (sysconfig.get_config_var('LIBDIR'))
-	except:
-		LDFLAGS.append("-L%s/lib" % sysconfig.PREFIX)
-		os.environ['LD_RUN_PATH'] = "%s/lib" % sysconfig.PREFIX
-
-
-version = sysconfig.get_config_var('VERSION')
-try:
-    version = version + sys.abiflags
-except:
-    pass
-LIBS.append('-lpython' + version)
+    LIBS = []
 
 #if str(PYLIB_PATH) != '':
 #                libs.insert(0,'-L' + PYLIB_PATH)

plugins/python/wsgi_handlers.c

@@ -46,11 +46,11 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
                 return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data");
         }
 
-	if (self->readline_max_size > 0 && self->readline_max_size < 1024) {
+	if (self->readline_max_size > 0 && self->readline_max_size < UWSGI_PY_READLINE_BUFSIZE) {
         	rlen = read(wsgi_req->poll.fd, self->readline, self->readline_max_size);
 	}
 	else {
-        	rlen = read(wsgi_req->poll.fd, self->readline, 1024);
+        	rlen = read(wsgi_req->poll.fd, self->readline, UWSGI_PY_READLINE_BUFSIZE);
 	}
         if (rlen <= 0) {
                 UWSGI_GET_GIL

plugins/python/wsgi_headers.c

@@ -191,9 +191,6 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		UWSGI_RELEASE_GIL
 		iov_ret = wsgi_req->socket->proto_writev_header(wsgi_req, iov_ptr, iov_size);
 		UWSGI_GET_GIL
-		if (iov_ret < 0) {
-			uwsgi_error("writev()");
-		}
 		wsgi_req->headers_size += iov_ret;
 		iov_ptr += iov_size;
 		remains -= iov_size;
@@ -202,9 +199,6 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 	UWSGI_RELEASE_GIL
 		wsgi_req->headers_size = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, j + 1);
 	UWSGI_GET_GIL
-		if (wsgi_req->headers_size < 0) {
-			uwsgi_error("writev()");
-		}
 #endif
 
 	//uwsgi_log("%d %p\n", wsgi_req->poll.fd, up.wsgi_writeout);

plugins/python/wsgi_subhandler.c

@@ -22,6 +22,10 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
                 pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len);
                 pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
 #endif
+
+#ifdef UWSGI_DEBUG
+		uwsgi_log("%p %d %p %d\n", pydictkey, wsgi_req->hvec[i].iov_len, pydictvalue, wsgi_req->hvec[i + 1].iov_len);
+#endif
                 PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
                 Py_DECREF(pydictkey);
                 Py_DECREF(pydictvalue);
@@ -43,6 +47,8 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
                 }
         }
 
+
+#ifndef UWSGI_PYPY
         // if async_post is mapped as a file, directly use it as wsgi.input
         if (wsgi_req->async_post) {
 #ifdef PYTHREE
@@ -61,7 +67,9 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
         }
 
+
         PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
+#endif
 
 #ifdef UWSGI_SENDFILE
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.file_wrapper", wi->sendfile);
@@ -77,12 +85,16 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.version", wi->gateway_version);
 
-	zero = PyFile_FromFile(stderr, "wsgi_input", "w", NULL);
+#ifndef UWSGI_PYPY
+	zero = PyFile_FromFile(stderr, "wsgi_errors", "w", NULL);
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.errors", zero);
 	Py_DECREF(zero);
+#endif
 
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.run_once", Py_False);
 
+
+
 	if (uwsgi.threads > 1) {
 		PyDict_SetItemString(wsgi_req->async_environ, "wsgi.multithread", Py_True);
 	}
@@ -116,10 +128,13 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
 	wsgi_req->async_app = wi->callable;
 
+
 	// export .env only in non-threaded mode
+#ifndef UWSGI_PYPY
 	if (uwsgi.threads < 2) {
 		PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
 	}
+#endif
 
 	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
 
@@ -179,7 +194,11 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 
 
 #ifdef UWSGI_SENDFILE
+#ifdef __FreeBSD__
+	if ( ((wsgi_req->sendfile_obj == wsgi_req->async_result) || ( wsgi_req->sendfile_fd_size > 0 && wsgi_req->response_size < wsgi_req->sendfile_fd_size)) && wsgi_req->sendfile_fd != -1) {
+#else
 	if (wsgi_req->sendfile_obj == wsgi_req->async_result && wsgi_req->sendfile_fd != -1) {
+#endif
 		sf_len = uwsgi_sendfile(wsgi_req);
 		if (sf_len < 1) goto clear;
 		wsgi_req->response_size += sf_len;

plugins/pyuwsgi/pyuwsgi.c

@@ -0,0 +1,75 @@
+#include "../python/uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+
+extern char **environ;
+
+PyObject *u_run(PyObject *self, PyObject *args) {
+
+        char **argv;
+        size_t size = 2;
+        int i;
+
+        if (PyTuple_Size(args) < 1) {
+		return PyErr_Format(PyExc_ValueError, "you have to specify at least one uWSGI option to run() it");
+	}
+
+	PyObject *the_arg = PyTuple_GetItem(args, 0);
+
+	if (PyList_Check(the_arg)) {
+        	size = PyList_Size(the_arg) + 2;
+	}
+	else if (PyTuple_Check(the_arg)) {
+        	size = PyTuple_Size(the_arg) + 2;
+	}
+	else if (PyString_Check(the_arg)) {
+		size = 3;
+	}
+
+        argv = uwsgi_malloc(sizeof(char *) * size);
+        memset(argv, 0, sizeof(char *) * size);
+
+        // will be overwritten
+        argv[0] = "uwsgi";
+
+	if (PyList_Check(the_arg)) {
+        	for(i=0;i<PyList_Size(the_arg);i++) {
+                	argv[i+1] = PyString_AsString( PyList_GetItem(the_arg, i) );
+        	}
+	}
+	else if (PyTuple_Check(the_arg)) {
+        	for(i=0;i<PyTuple_Size(the_arg);i++) {
+                	argv[i+1] = PyString_AsString( PyTuple_GetItem(the_arg, i) );
+        	}
+	}
+	else if (PyString_Check(the_arg)) {
+		argv[1] = PyString_AsString( the_arg );
+	}
+
+        uwsgi_init(size-1, argv, environ);
+
+        Py_INCREF(Py_None);
+        return Py_None;
+}
+
+PyMethodDef methods[] = {
+    {"run", u_run, METH_VARARGS, "run the uWSGI server"},
+    {NULL, NULL, 0, NULL}
+};
+
+PyMODINIT_FUNC
+initpyuwsgi()
+{
+    (void) Py_InitModule("pyuwsgi", methods);
+}
+
+
+int pyuwsgi_init() { return 0; }
+
+struct uwsgi_plugin pyuwsgi_plugin = {
+
+        .name = "pyuwsgi",
+        .init = pyuwsgi_init,
+};
+

plugins/pyuwsgi/uwsgiplugin.py

@@ -0,0 +1,11 @@
+from distutils import sysconfig
+import os
+
+os.environ['UWSGI_PYTHON_NOLIB'] = '1'
+
+NAME='pyuwsgi'
+CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True)]
+LDFLAGS = []
+LIBS = []
+
+GCC_LIST = ['pyuwsgi']

plugins/rack/rack_plugin.c

@@ -9,6 +9,7 @@ struct option uwsgi_rack_options[] = {
         {"rails", required_argument, 0, LONG_ARGS_RAILS},
         {"rack", required_argument, 0, LONG_ARGS_RACK},
         {"ruby-gc-freq", required_argument, 0, LONG_ARGS_RUBY_GC_FREQ},
+        {"rbshell", optional_argument, 0, LONG_ARGS_RUBY_SHELL},
 
         {0, 0, 0, 0},
 
@@ -920,6 +921,9 @@ int uwsgi_rack_mount_app(char *mountpoint, char *app) {
 }
 */
 
+void uwsgi_rack_hijack(void) {
+}
+
 struct uwsgi_plugin rack_plugin = {
 
 	.name = "rack",
@@ -932,6 +936,8 @@ struct uwsgi_plugin rack_plugin = {
 
 	.signal_handler = uwsgi_rack_signal_handler,
 
+	.hijack = uwsgi_rack_hijack,
+
 	.init_apps = uwsgi_rack_init_apps,
 	//.mount_app = uwsgi_rack_mount_app,
 	.manage_xml = uwsgi_rack_xml,

plugins/rack/uwsgi_rack.h

@@ -6,6 +6,7 @@
 #define LONG_ARGS_RAILS         LONG_ARGS_RACK_BASE + 1
 #define LONG_ARGS_RUBY_GC_FREQ  LONG_ARGS_RACK_BASE + 2
 #define LONG_ARGS_RACK          LONG_ARGS_RACK_BASE + 3
+#define LONG_ARGS_RUBY_SHELL    LONG_ARGS_RACK_BASE + 4
 
 #ifndef RUBY19
         #define rb_errinfo() ruby_errinfo
@@ -59,6 +60,8 @@ struct uwsgi_rack {
 
         pthread_mutex_t gvl;
 
+	int rb_shell;
+
 };
 
 void uwsgi_ruby_exception(void);

plugins/rrdtool/rrdtool.c

@@ -0,0 +1,188 @@
+#include "../../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+#define RRDTOOL_OPT_BASE 177000
+#define RRDTOOL_OPT_RRDTOOL		RRDTOOL_OPT_BASE+1
+#define RRDTOOL_OPT_RRDTOOL_MAX_DS	RRDTOOL_OPT_BASE+2
+
+struct uwsgi_rrdtool {
+	void *lib;
+	int (*create)(int, char **);
+	int (*update)(int, char **);
+	struct uwsgi_string_list *rrd;
+	int max_ds;
+
+	char *update_area;
+} u_rrd;
+
+struct option rrdtool_options[] = {
+	{"rrdtool", required_argument, 0, RRDTOOL_OPT_RRDTOOL},
+	{"rrdtool-max-ds", required_argument, 0, RRDTOOL_OPT_RRDTOOL_MAX_DS},
+	{0, 0, 0, 0},
+
+};
+
+
+int rrdtool_init() {
+
+	u_rrd.lib = dlopen("librrd.so", RTLD_LAZY);
+	if (!u_rrd.lib) return -1;
+
+	u_rrd.create = dlsym(u_rrd.lib, "rrd_create");
+	if (!u_rrd.create) {
+		dlclose(u_rrd.lib);
+		return -1;
+	}
+
+	u_rrd.update = dlsym(u_rrd.lib, "rrd_update");
+	if (!u_rrd.update) {
+		dlclose(u_rrd.lib);
+		return -1;
+	}
+
+	if (!u_rrd.max_ds) u_rrd.max_ds = 30;
+
+	uwsgi_log("*** RRDtool library available at %p ***\n", u_rrd.lib);
+
+	return 0;
+}
+
+int rrdtool_opt(int i, char *optarg) {
+
+	switch(i) {
+		case RRDTOOL_OPT_RRDTOOL:
+			uwsgi.master_process = 1;
+			uwsgi_string_new_list(&u_rrd.rrd, optarg);
+			return 1;
+		case RRDTOOL_OPT_RRDTOOL_MAX_DS:
+			u_rrd.max_ds = atoi(optarg);
+			return 1;
+	}
+
+	return 0;
+}
+
+void rrdtool_post_init() {
+
+	struct uwsgi_string_list *usl = u_rrd.rrd;
+	char **argv;
+	int i;
+
+	if (!u_rrd.lib || !u_rrd.create) return;
+
+	// do not waste time if no --rrdtool option is defiend
+	if (!u_rrd.rrd) return;
+
+	if (uwsgi.numproc > u_rrd.max_ds) {
+		uwsgi_log("!!! NOT ENOUGH SLOTS IN RRDTOOL DS TO HOST WORKERS DATA (increase them with --rrdtool-max-ds) !!!\n");
+		dlclose(u_rrd.lib);
+		return;
+	}
+
+	// alloc space for DS_REQ + DS WORKER + RRA + create + filename
+	argv = uwsgi_malloc( sizeof(char *) * (1 + u_rrd.max_ds + 4 + 1 +1));
+
+	argv[0] = "create";
+
+	argv[2] = "DS:requests:DERIVE:600:0:U";
+
+	// create DS for workers
+	for(i=0;i<u_rrd.max_ds;i++) {
+		int max_size = sizeof("DS:worker65536:DERIVE:600:0:U")+1;
+		argv[3+i] = uwsgi_malloc( max_size );
+		if (snprintf(argv[3+i], max_size, "DS:worker%d:DERIVE:600:0:U", i+1) < 25) {
+			uwsgi_log("unable to create args for rrd_create()\n");
+			exit(1);
+		}
+	}
+
+	// create RRA
+	argv[3+u_rrd.max_ds] = "RRA:AVERAGE:0.5:1:288" ;
+	argv[3+u_rrd.max_ds+1] = "RRA:AVERAGE:0.5:12:168" ;
+	argv[3+u_rrd.max_ds+2] = "RRA:AVERAGE:0.5:288:31" ;
+	argv[3+u_rrd.max_ds+3] = "RRA:AVERAGE:0.5:2016:52";
+
+	while(usl) {
+		if (!uwsgi_file_exists(usl->value)) {
+			argv[1] = usl->value;	
+			if (u_rrd.create((1 + u_rrd.max_ds + 4 + 1 +1), argv)) {
+				uwsgi_error("rrd_create()");
+				exit(1);
+			}
+		}
+		usl->value = realpath(usl->value, NULL);
+		if (!usl->value) {
+			uwsgi_error("realpath()");
+			exit(1);
+		}
+		usl = usl->next;
+	}
+
+	// free DS
+	for(i=0;i<u_rrd.max_ds;i++) {
+		free(argv[3+i]);
+	}
+
+	free(argv);
+
+	//now allocate memory for updates
+	u_rrd.update_area = uwsgi_malloc( 1+((1+sizeof(UMAX64_STR)) * (u_rrd.max_ds+1))+1 );
+	memset(u_rrd.update_area, 0, 1+((1+sizeof(UMAX64_STR)) * (u_rrd.max_ds+1))+1 );
+
+	u_rrd.update_area[0] = 'N';	
+
+}
+
+void rrdtool_master_cycle() {
+
+	static time_t last_update = 0;
+	char *ptr;
+	int rlen, i;
+	char *argv[3];
+	struct uwsgi_string_list *usl = u_rrd.rrd;
+
+	if (!u_rrd.lib || !u_rrd.create || !u_rrd.rrd) return ;
+
+	if (last_update == 0) last_update = time(NULL);
+
+	// update every 5 minutes
+	if (uwsgi.current_time - last_update >= 300) {
+		ptr = u_rrd.update_area+1;
+		rlen = snprintf(ptr, 1+sizeof(UMAX64_STR), ":%llu", (unsigned long long )uwsgi.workers[0].requests);
+		if (rlen < 2) return;
+		ptr+=rlen;
+		for(i=0;i<u_rrd.max_ds;i++) {
+			if (i+1 <= uwsgi.numproc) {
+				rlen = snprintf(ptr, 1+sizeof(UMAX64_STR), ":%llu", (unsigned long long )uwsgi.workers[1+i].requests);
+				if (rlen < 2) return;
+			}
+			else {
+				memcpy(ptr, ":U", 2);
+				rlen = 2;
+			}
+			ptr+=rlen;
+		}
+		last_update = uwsgi.current_time;
+		argv[0] = "update";
+		argv[2] = u_rrd.update_area;
+		while(usl) {
+			argv[1] = usl->value;
+			if (u_rrd.update(3, argv)) {
+				uwsgi_log_verbose("ERROR: rrd_update(\"%s\", \"%s\")\n", argv[1], argv[2]);
+			}
+			usl = usl->next;
+		}
+	}
+}
+
+struct uwsgi_plugin rrdtool_plugin = {
+	
+	.options = rrdtool_options,
+	.manage_opt = rrdtool_opt,
+
+	.master_cycle = rrdtool_master_cycle,
+	
+	.post_init = rrdtool_post_init,
+	.init = rrdtool_init,
+};

plugins/rrdtool/uwsgiplugin.py

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

proto/http.c

@@ -46,6 +46,12 @@ static uint16_t http_add_uwsgi_header(struct wsgi_request *wsgi_req, char *hh, i
         		wsgi_req->if_modified_since = val;
                 	wsgi_req->if_modified_since_len = vallen;
         	}
+		else if (!uwsgi_strncmp("X_FORWARDED_SSL", 15, hh, keylen)) {
+			if (vallen == 2 && val[0] == 'o' && val[1] == 'n') {
+				wsgi_req->scheme = "https";
+				wsgi_req->scheme_len = 5;
+			}
+		}
 		else if (uwsgi.vhost_host && !uwsgi_strncmp("HOST", 4, hh, keylen)) {
         		wsgi_req->host = val;
                 	wsgi_req->host_len = vallen;
@@ -100,6 +106,8 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	char ip[INET_ADDRSTRLEN+1];
 	struct sockaddr_in *http_sin = (struct sockaddr_in *) &wsgi_req->c_addr;
 
+	wsgi_req->path_info_pos = -1;
+
 	// REQUEST_METHOD 
 	while (ptr < watermark) {
 		if (*ptr == ' ') {
@@ -116,9 +124,19 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	base = ptr;
 	while (ptr < watermark) {
 		if (*ptr == '?' && !query_string) {
-			wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
-			wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
-			wsgi_req->path_info_len = ptr - base;
+			if (watermark + (ptr - base) < (char *)(wsgi_req->proto_parser_buf + uwsgi.buffer_size)) {
+				wsgi_req->path_info = watermark;
+				wsgi_req->path_info_len = ptr - base;
+				http_url_decode(base, &wsgi_req->path_info_len, wsgi_req->path_info);
+				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, wsgi_req->path_info, wsgi_req->path_info_len);
+			}
+			else {
+				uwsgi_log("not enough space in wsgi_req http proto_parser_buf to encode PATH_INFO, consider tuning it with --buffer-size\n");
+				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
+				wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+				wsgi_req->path_info_len = ptr - base;
+			}
+			wsgi_req->path_info_pos = 3;
 			query_string = ptr + 1;
 		}
 		else if (*ptr == ' ') {
@@ -127,9 +145,19 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 			wsgi_req->uri_len = ptr - base;
 			
 			if (!query_string) {
-				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
-				wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
-				wsgi_req->path_info_len = ptr - base;
+				if (watermark + (ptr - base) < (char *)(wsgi_req->proto_parser_buf + uwsgi.buffer_size)) {
+                                	wsgi_req->path_info = watermark;
+                                	wsgi_req->path_info_len = ptr - base;
+                                	http_url_decode(base, &wsgi_req->path_info_len, wsgi_req->path_info);
+                                	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, wsgi_req->path_info, wsgi_req->path_info_len);
+                        	}
+				else {
+					uwsgi_log("not enough space in wsgi_req http proto_parser_buf to encode PATH_INFO, consider tuning it with --buffer-size\n");
+					wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
+					wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+					wsgi_req->path_info_len = ptr - base;
+				}
+				wsgi_req->path_info_pos = 5;
 				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
 			}
 			else {
@@ -161,7 +189,10 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	}
 
 	// SCRIPT_NAME
-	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
+	if (!uwsgi.manage_script_name) {
+		wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SCRIPT_NAME", 11, "", 0);
+	}
+	
 
 	// SERVER_NAME
 	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
@@ -261,7 +292,11 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 	len = read(wsgi_req->poll.fd, wsgi_req->proto_parser_buf + wsgi_req->proto_parser_pos, uwsgi.buffer_size - wsgi_req->proto_parser_pos);
 	if (len <= 0) {
 		free(wsgi_req->proto_parser_buf);
-		uwsgi_error("recv()");
+		if (len < 0) {
+			uwsgi_error("recv()");
+		}
+		// this is simple ping packet
+		else { return -2; }
 		return -1;
 	}
 

proto/uwsgi.c

@@ -115,17 +115,37 @@ int uwsgi_proto_uwsgi_parser(struct wsgi_request *wsgi_req) {
 }
 
 ssize_t uwsgi_proto_uwsgi_writev_header(struct wsgi_request * wsgi_req, struct iovec * iovec, size_t iov_len) {
-	return writev(wsgi_req->poll.fd, iovec, iov_len);
+	ssize_t wlen = writev(wsgi_req->poll.fd, iovec, iov_len);
+	if (wlen < 0) {
+		uwsgi_req_error("writev()");
+		return 0;
+	}
+	return wlen;
 }
 
 ssize_t uwsgi_proto_uwsgi_writev(struct wsgi_request * wsgi_req, struct iovec * iovec, size_t iov_len) {
-	return writev(wsgi_req->poll.fd, iovec, iov_len);
+	ssize_t wlen = writev(wsgi_req->poll.fd, iovec, iov_len);
+	if (wlen < 0) {
+		uwsgi_req_error("writev()");
+		return 0;
+	}
+	return wlen;
 }
 
 ssize_t uwsgi_proto_uwsgi_write(struct wsgi_request * wsgi_req, char *buf, size_t len) {
-	return write(wsgi_req->poll.fd, buf, len);
+	ssize_t wlen = write(wsgi_req->poll.fd, buf, len);
+	if (wlen < 0) {
+		uwsgi_req_error("write()");
+		return 0;
+	}
+	return wlen;
 }
 
 ssize_t uwsgi_proto_uwsgi_write_header(struct wsgi_request * wsgi_req, char *buf, size_t len) {
-	return write(wsgi_req->poll.fd, buf, len);
+	ssize_t wlen = write(wsgi_req->poll.fd, buf, len);
+	if (wlen < 0) {
+		uwsgi_req_error("write()");
+		return 0;
+	}
+	return wlen;
 }

protocol.c

@@ -366,7 +366,10 @@ int uwsgi_parse_packet(struct wsgi_request *wsgi_req, int timeout) {
 			status = uwsgi_proto_uwsgi_parser(wsgi_req);
 		}
 		if (status < 0) {
-			uwsgi_log("error parsing request\n");
+			if (status == -1)
+				uwsgi_log("error parsing request\n");
+			else if (status == -2)
+				uwsgi_log("open-close packet (ping/check) received\n");
 			//close(upoll->fd);
 			return 0;
 		}
@@ -496,7 +499,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 
 	ptrbuf = buffer;
 	bufferend = ptrbuf + wsgi_req->uh.pktsize;
-	int i, script_name= -1, path_info= -1;
+	int i, script_name= -1;
 
 	/* set an HTTP 500 status as default */
 	wsgi_req->status = 500;
@@ -508,6 +511,8 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 		return i;
 	}
 
+	wsgi_req->path_info_pos = -1;
+
 	while (ptrbuf < bufferend) {
 		if (ptrbuf + 2 < bufferend) {
 			memcpy(&strsize, ptrbuf, 2);
@@ -546,7 +551,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 						else if (!uwsgi_strncmp("PATH_INFO", 9, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->path_info = ptrbuf;
 							wsgi_req->path_info_len = strsize;
-							path_info = wsgi_req->var_cnt + 1;
+							wsgi_req->path_info_pos = wsgi_req->var_cnt + 1;
 #ifdef UWSGI_DEBUG
 							uwsgi_debug("PATH_INFO=%.*s\n", wsgi_req->path_info_len, wsgi_req->path_info);
 #endif
@@ -567,7 +572,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->method = ptrbuf;
 							wsgi_req->method_len = strsize;
 						}
-						else if (!uwsgi_strncmp("REMOTE_ADDR", 11, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+						else if (!uwsgi.log_x_forwarded_for && !uwsgi_strncmp("REMOTE_ADDR", 11, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->remote_addr = ptrbuf;
 							wsgi_req->remote_addr_len = strsize;
 						}
@@ -652,6 +657,10 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->if_modified_since = ptrbuf;
 							wsgi_req->if_modified_since_len = strsize;
 						}
+						else if (uwsgi.log_x_forwarded_for && !uwsgi_strncmp("HTTP_X_FORWARDED_FOR", 20, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+							wsgi_req->remote_addr = ptrbuf;
+							wsgi_req->remote_addr_len = strsize;
+						}
 						else if (!uwsgi_strncmp("CONTENT_TYPE", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->content_type = ptrbuf;
 							wsgi_req->content_type_len = strsize;
@@ -749,7 +758,7 @@ next:
 	}
 
 	if (uwsgi.manage_script_name) {
-		if (uwsgi_apps_cnt > 0 && wsgi_req->path_info_len > 1) {
+		if (uwsgi_apps_cnt > 0 && wsgi_req->path_info_len > 1 && wsgi_req->path_info_pos != -1) {
 			// starts with 1 as the 0 app is the default (/) one
 			int best_found = 0;
 			char *orig_path_info = wsgi_req->path_info;
@@ -760,11 +769,13 @@ next:
 					uwsgi_log( "max vec size reached. skip this var.\n");
                                         return -1;
 				}
-				wsgi_req->var_cnt++;
 				wsgi_req->hvec[wsgi_req->var_cnt].iov_base = "SCRIPT_NAME";
                                 wsgi_req->hvec[wsgi_req->var_cnt].iov_len = 11;
 				wsgi_req->var_cnt++;
 				script_name = wsgi_req->var_cnt;
+				wsgi_req->hvec[script_name].iov_base = "";
+				wsgi_req->hvec[script_name].iov_len = 0;
+				wsgi_req->var_cnt++;
 			}
 
 			for(i=0;i<uwsgi_apps_cnt;i++) {
@@ -780,8 +791,8 @@ next:
 						wsgi_req->hvec[script_name].iov_base = wsgi_req->script_name;
 						wsgi_req->hvec[script_name].iov_len = wsgi_req->script_name_len;
 
-						wsgi_req->hvec[path_info].iov_base = wsgi_req->path_info;
-						wsgi_req->hvec[path_info].iov_len = wsgi_req->path_info_len;
+						wsgi_req->hvec[wsgi_req->path_info_pos].iov_base = wsgi_req->path_info;
+						wsgi_req->hvec[wsgi_req->path_info_pos].iov_len = wsgi_req->path_info_len;
 #ifdef UWSGI_DEBUG
 						uwsgi_log("managed SCRIPT_NAME = %.*s PATH_INFO = %.*s\n", wsgi_req->script_name_len, wsgi_req->script_name, wsgi_req->path_info_len, wsgi_req->path_info);
 #endif
@@ -1325,6 +1336,48 @@ int uwsgi_simple_send_string(char *socket_name, uint8_t modifier1, uint8_t modif
         return 0;
 }
 
+char *uwsgi_get_mime_type(char *name, int namelen, int *size) {
+
+	int i;
+	int count = 0;
+	char *ext = NULL;
+	for(i=namelen-1;i>=0;i--) {
+		if (!isalnum( (int)name[i])) {
+			if (name[i] == '.') {
+				ext = name+(namelen-count);
+				break;
+			}
+		}
+		count++;
+	}
+
+	if (ext) {
+		struct uwsgi_dyn_dict *udd = uwsgi.mimetypes;
+		while(udd) {
+			if (!uwsgi_strncmp(ext, count, udd->key, udd->keylen)) {
+				udd->hits++;
+				// auto optimization
+				if (udd->prev) {
+					if (udd->hits > udd->prev->hits) {
+						struct uwsgi_dyn_dict *udd_parent = udd->prev->prev, *udd_prev = udd->prev;
+						if (udd_parent) {
+							udd_parent->next = udd;
+						}
+						udd_prev->prev = udd;
+						udd_prev->next = udd->next;
+
+						udd->prev = udd_parent;
+						udd->next = udd_prev;
+					}
+				}
+				*size = udd->vallen;
+				return udd->value;
+			}
+			udd = udd->next;
+		}
+	}
+	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) {
 
@@ -1349,6 +1402,8 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
                 return -1;
         }
         if (!stat(real_filename, &st)) {
+		int mime_type_size = 0;
+		char *mime_type = uwsgi_get_mime_type(path_info, path_info_len, &mime_type_size);
                 if (wsgi_req->if_modified_since_len) {
                         time_t ims = parse_http_date(wsgi_req->if_modified_since, wsgi_req->if_modified_since_len);
                         if (st.st_mtime <= ims) {
@@ -1381,11 +1436,19 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
 			while(ah) {
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, ah->value, ah->len);
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2);
+				wsgi_req->header_cnt++;
 				ah = ah->next;
 			}
 
+			if (mime_type_size > 0 && mime_type) {
+				wsgi_req->header_cnt++;
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "Content-Type: ", 14);
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, mime_type, mime_type_size);
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2);
+			}
+
 			if (uwsgi.file_serve_mode == 1) {
-                                wsgi_req->header_cnt = 2;
+                                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] != '/') {
@@ -1397,7 +1460,7 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
                         	wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, http_last_modified, 48);
 			}
 			else if (uwsgi.file_serve_mode == 2) {
-                                wsgi_req->header_cnt = 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] != '/') {
@@ -1409,7 +1472,7 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
                         	wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, http_last_modified, 48);
 			}
 			else {
-                                wsgi_req->header_cnt = 1;
+                                wsgi_req->header_cnt += 1;
                         	set_http_date(st.st_mtime, http_last_modified);
                         	wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, http_last_modified, 48);
                                 wsgi_req->sendfile_fd = open(real_filename, O_RDONLY);

pypyuwsgi.py

@@ -0,0 +1,18 @@
+import sys
+import os
+import pyuwsgi
+
+orig_args = sys.argv
+orig_executable = sys.executable
+orig_args.insert(0, orig_executable)
+
+uwsgi_args = []
+
+for arg in sys.argv[2:]:
+    uwsgi_args.append(arg)
+
+#pyuwsgi.run('welcome.ini')
+pyuwsgi.run(uwsgi_args)
+
+# if you are here uWSGI has been reloaded
+os.execv(orig_executable, orig_args)

pyuwsgi_run.py

@@ -0,0 +1,22 @@
+import sys
+import os
+import pyuwsgi
+
+orig_args = sys.argv
+orig_executable = sys.executable
+orig_args.insert(0, orig_executable)
+
+uwsgi_args = []
+
+uwsgi_args.append('--socket')
+uwsgi_args.append(':3031')
+#uwsgi_args.append('--master')
+uwsgi_args.append('--module')
+#uwsgi_args.append('welcome')
+uwsgi_args.append('hello')
+
+#pyuwsgi.run('welcome.ini')
+pyuwsgi.run(uwsgi_args)
+
+# if you are here uWSGI has been reloaded
+os.execv(orig_executable, orig_args)

regexp.c

@@ -1,35 +1,31 @@
 #ifdef UWSGI_PCRE
-
 #include "uwsgi.h"
 
-#include <pcre.h>
+int uwsgi_regexp_build(char *re, pcre **pattern, pcre_extra **pattern_extra) {
 
-/*
+	const char *errstr;
+	int erroff;
 
-void uwsgi_regexp_match(regexp, what) {
-
-	int ret,i;
-
-	for(i=0;i<uwsgi->nroutes;i++) {
-
-		ret = pcre_exec(ur->pattern, ur->pattern_extra, wsgi_req->path_info, wsgi_req->path_info_len, 0, 0, wsgi_req->ovector, (ur->args+1)*3 );
-
-		if (ret >= 0) {
-			if (ur->action) {
-				ur->action(uwsgi, wsgi_req, ur);
-			}
-			else {
-				uwsgi_route_action_wsgi(uwsgi, wsgi_req, ur);
-			}
-		}
-
-		// TODO check for errors if < 0 && != NO_MATCH
+	*pattern = pcre_compile( (const char *)re, 0, &errstr, &erroff, NULL);
+        if (!*pattern) {
+		uwsgi_log("pcre error: %s at offset %d\n", errstr, erroff);
+		return -1;
 	}
 
-	return;
+	*pattern_extra = (pcre_extra *) pcre_study((const pcre*)*pattern, 0, &errstr);
+        if (!*pattern_extra) {
+		pcre_free(*pattern);
+		uwsgi_log("pcre (study) error: %s\n", errstr);
+		return -1;
+	}
+
+	return 0;
+	
 }
 
-*/
+int uwsgi_regexp_match(pcre *pattern, pcre_extra *pattern_extra, char *subject, int length) {
 
+	return pcre_exec((const pcre*)pattern, (const pcre_extra *)pattern_extra, subject, length, 0, 0, NULL, 0 );
+}
 
 #endif

sendfile.c

@@ -56,9 +56,11 @@ ssize_t uwsgi_do_sendfile(int sockfd, int filefd, size_t filesize, size_t chunk,
 		sf_ret = sendfile(filefd, sockfd, 0, 0, NULL, &sf_len, 0);
 	}
 
-	if (sf_ret) {
-		uwsgi_error("sendfile()");
-		return 0;
+	if (sf_ret < 0) {
+		if (errno != EAGAIN) {
+			uwsgi_error("sendfile()");
+			return 0;
+		}
 	}
 
 	return sf_len;

setup.py

@@ -6,8 +6,15 @@ import shutil
 from setuptools import setup
 from setuptools.dist import Distribution
 from setuptools.command.install import install
+from setuptools.command.install_lib import install_lib
 from setuptools.command.build_ext import build_ext
 
+"""
+This is a hack allowing you installing uWSGI and uwsgidecorators via pip and easy_install
+"""
+
+uwsgi_compiled = False
+
 def get_profile():
     profile = os.environ.get('UWSGI_PROFILE','buildconf/default.ini')
     if not profile.endswith('.ini'):
@@ -34,30 +41,44 @@ def patch_bin_path(cmd, conf):
 class uWSGIBuilder(build_ext):
 
     def run(self):
-        conf = uc.uConf(get_profile())
-        patch_bin_path(self, conf)
-        uc.build_uwsgi( conf )
+        global uwsgi_compiled
+        if not uwsgi_compiled:
+            conf = uc.uConf(get_profile())
+            patch_bin_path(self, conf)
+            uc.build_uwsgi( conf )
+            uwsgi_compiled = True
 
 
 class uWSGIInstall(install):
 
     def run(self):
-        # hack, hack and still hack. We need to find a solution...
-        if self.record:
-            record_file = open(self.record,'w')
+        global uwsgi_compiled
+        if not uwsgi_compiled:
+            conf = uc.uConf(get_profile())
+            patch_bin_path(self, conf)
+            uc.build_uwsgi( conf )
+            uwsgi_compiled = True
+        install.run(self)
 
-        conf = uc.uConf(get_profile())
-        patch_bin_path(self, conf)
-        uc.build_uwsgi( conf )
+class uWSGIInstallLib(install_lib):
+
+    def run(self):
+        global uwsgi_compiled
+        if not uwsgi_compiled:
+            conf = uc.uConf(get_profile())
+            patch_bin_path(self, conf)
+            uc.build_uwsgi( conf )
+            uwsgi_compiled = True
+        install_lib.run(self)
 
 class uWSGIDistribution(Distribution):
 
     def __init__(self, *attrs):
         Distribution.__init__(self, *attrs)
         self.cmdclass['install'] = uWSGIInstall
+        self.cmdclass['install_lib'] = uWSGIInstallLib
         self.cmdclass['build_ext'] = uWSGIBuilder
 
-
 setup(name='uWSGI',
       version=uc.uwsgi_version,
       description='The uWSGI server',
@@ -65,6 +86,7 @@ setup(name='uWSGI',
       author_email='info@unbit.it',
       url='http://projects.unbit.it/uwsgi/',
       license='GPL2',
+      py_modules = ['uwsgidecorators'],
       distclass = uWSGIDistribution,
      )
 

signal.c

@@ -12,7 +12,55 @@ int uwsgi_signal_handler(uint8_t sig) {
 		return -1;
 	}	
 
-	return uwsgi.p[use->modifier1]->signal_handler(sig, use->handler);
+        // set harakiri here (if required and if i am a worker)
+	
+	if (uwsgi.mywid > 0) {
+                uwsgi.workers[uwsgi.mywid].sig = 1;
+                uwsgi.workers[uwsgi.mywid].signum = sig;
+		uwsgi.workers[uwsgi.mywid].signals++;
+		if(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {
+                	set_harakiri(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI]);
+		}
+        }
+	else if (uwsgi.muleid > 0) {
+                uwsgi.mules[uwsgi.muleid-1].sig = 1;
+                uwsgi.mules[uwsgi.muleid-1].signum = sig;
+		uwsgi.mules[uwsgi.muleid-1].signals++;
+		if(uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI] > 0) {
+                	set_mule_harakiri(uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI]);
+		}
+	}
+#ifdef UWSGI_SPOOLER
+        else if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0 && (getpid() == uwsgi.shared->spooler_pid)) {
+		if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+                        set_spooler_harakiri(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI]);
+                }
+        }
+#endif
+
+	int ret = uwsgi.p[use->modifier1]->signal_handler(sig, use->handler);
+
+	if (uwsgi.mywid > 0) {
+                uwsgi.workers[uwsgi.mywid].sig = 0;
+		if(uwsgi.workers[uwsgi.mywid].harakiri > 0) {
+                	set_harakiri(0);
+		}
+        }
+	else if (uwsgi.muleid > 0) {
+                uwsgi.mules[uwsgi.muleid-1].sig = 0;
+		if(uwsgi.mules[uwsgi.muleid-1].harakiri > 0) {
+                	set_mule_harakiri(0);
+		}
+        }
+#ifdef UWSGI_SPOOLER
+        else if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0 && (getpid() == uwsgi.shared->spooler_pid)) {
+		if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+                        set_spooler_harakiri(0);
+                }
+        }
+#endif
+
+	return ret;
 }
 
 int uwsgi_signal_registered(uint8_t sig) {
@@ -166,7 +214,7 @@ void uwsgi_route_signal(uint8_t sig) {
 	// send to all workers
 	else if (!strcmp(use->receiver, "workers")) {
 		for(i=1;i<=uwsgi.numproc;i++) {
-			if (write(uwsgi.signal_pipe[i][0], &sig, 1) != 1) {
+			if (write(uwsgi.workers[i].signal_pipe[0], &sig, 1) != 1) {
 				uwsgi_error("write()");
 				uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
 			}
@@ -178,7 +226,7 @@ void uwsgi_route_signal(uint8_t sig) {
 		if (i > uwsgi.numproc) {
 			uwsgi_log("invalid signal target: %s\n", use->receiver);
 		}
-		if (write(uwsgi.signal_pipe[i][0], &sig, 1) != 1) {
+		if (write(uwsgi.workers[i].signal_pipe[0], &sig, 1) != 1) {
                         uwsgi_error("write()");
                 	uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
                 }
@@ -187,6 +235,7 @@ void uwsgi_route_signal(uint8_t sig) {
 	else if (!strcmp(use->receiver, "subscribed")) {
 	}
 	// route to spooler
+#ifdef UWSGI_SPOOLER
 	else if (!strcmp(use->receiver, "spooler")) {
 		if (ushared->worker_signal_pipe[0] != -1) {
 			if (write(ushared->spooler_signal_pipe[0], &sig, 1) != 1) {
@@ -195,6 +244,58 @@ void uwsgi_route_signal(uint8_t sig) {
                 	}
 		}
 	}
+#endif
+	else if (!strcmp(use->receiver, "mules")) {
+		for(i=0;i<uwsgi.mules_cnt;i++) {
+			if (write(uwsgi.mules[i].signal_pipe[0], &sig, 1) != 1) {
+                                uwsgi_error("write()");
+                                uwsgi_log("could not deliver signal %d to mule %d\n", sig, i+1);
+                        }
+		}
+	}
+	else if (!strncmp(use->receiver, "mule", 4)) {
+		i = atoi(use->receiver+4);
+		if (i > uwsgi.mules_cnt) {
+			uwsgi_log("invalid signal target: %s\n", use->receiver);
+		}
+		else if (i == 0) {
+			if (write(ushared->mule_signal_pipe[0], &sig, 1) != 1) {
+                                uwsgi_error("write()");
+                                uwsgi_log("could not deliver signal %d to a mule\n", sig);
+                        }
+		}
+		else {
+			if (write(uwsgi.mules[i-1].signal_pipe[0], &sig, 1) != 1) {
+                                uwsgi_error("write()");
+                                uwsgi_log("could not deliver signal %d to mule %d\n", sig, i);
+                        }
+		}
+	}
+	else if (!strncmp(use->receiver, "farm_", 5)) {
+		char *name = use->receiver+5;
+		struct uwsgi_farm *uf = get_farm_by_name(name);
+		if (!uf) {
+			uwsgi_log("unknown farm: %s\n", name);
+			return;
+		}
+		if (write(uf->signal_pipe[0], &sig, 1) != 1) {
+                	uwsgi_error("write()");
+                        uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, uf->id, uf->name);
+                }
+	}
+	else if (!strncmp(use->receiver, "farm", 4)) {
+		i = atoi(use->receiver+4);
+		if (i > uwsgi.farms_cnt || i <= 0) {
+			uwsgi_log("invalid signal target: %s\n", use->receiver);
+		}
+		else {
+			if (write(uwsgi.farms[i-1].signal_pipe[0], &sig, 1) != 1) {
+                                uwsgi_error("write()");
+                                uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, i, uwsgi.farms[i-1].name);
+                        }
+		}
+	}
+
 	else {
 		// unregistered signal, sending it to all the workers
 		uwsgi_log("^^^ UNSUPPORTED SIGNAL TARGET: %s ^^^\n", use->receiver);

socket.c

@@ -755,6 +755,20 @@ struct uwsgi_socket *uwsgi_new_socket(char *name) {
 
 	if (!name) return uwsgi_sock;
 
+	if (name[0] == '=') {
+		int shared_socket = atoi(uwsgi_sock->name+1);
+                if (shared_socket >= 0) {
+                	struct uwsgi_socket *uss = uwsgi_get_shared_socket_by_num(shared_socket);
+                        if (!uss) {
+                        	uwsgi_log("unable to use shared socket %d\n", shared_socket);
+				exit(1);
+                        }
+			uwsgi_sock->bound = 1;
+			uwsgi_sock->shared = 1;
+			uwsgi_sock->from_shared = shared_socket;
+			return uwsgi_sock;
+                }
+	}
 	char *tcp_port = strchr(name, ':');
 	if (tcp_port) {
 		// INET socket, check for 0 port
@@ -957,6 +971,29 @@ int uwsgi_get_shared_socket_fd_by_num(int num) {
 	return -1;
 }
 
+struct uwsgi_socket *uwsgi_get_shared_socket_by_num(int num) {
+
+        int counter = 0;
+
+        struct uwsgi_socket *found_sock = NULL, *uwsgi_sock = uwsgi.shared_sockets;
+
+        while(uwsgi_sock) {
+                if (counter == num) {
+                        found_sock = uwsgi_sock;
+                        break;
+                }
+                counter++;
+                uwsgi_sock = uwsgi_sock->next;
+        }
+
+        if (found_sock) {
+                return found_sock;
+        }
+
+        return NULL;
+}
+
+
 void uwsgi_add_sockets_to_queue(int queue) {
 
 	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;

spooler.c

@@ -16,20 +16,7 @@ pid_t spooler_start() {
 	
 	int i;
 
-	if (uwsgi.master_process) {
-		if (uwsgi.shared->spooler_signal_pipe[0] != -1) {close (uwsgi.shared->spooler_signal_pipe[0]); uwsgi.shared->spooler_signal_pipe[0] = -1;}
-		if (!uwsgi.spooler_respawned) {
-			if (uwsgi.shared->spooler_signal_pipe[1] != -1) {close (uwsgi.shared->spooler_signal_pipe[1]); uwsgi.shared->spooler_signal_pipe[1] = -1;}
-		}
-		// setup internal signalling system
-                if (socketpair(AF_UNIX, SOCK_STREAM, 0, uwsgi.shared->spooler_signal_pipe)) {
-                        uwsgi_error("socketpair()\n");
-                        exit(1);
-                }
-	}
-
-
-	pid_t pid = fork();
+	pid_t pid = uwsgi_fork("uWSGI spooler");
 	if (pid < 0) {
 		uwsgi_error("fork()");
 		exit(1);
@@ -41,15 +28,9 @@ pid_t spooler_start() {
 		uwsgi.mypid = getpid();
 		// avoid race conditions !!!
 		uwsgi.shared->spooler_pid = uwsgi.mypid;
+
+		uwsgi_fixup_fds(0, 0);
 		uwsgi_close_all_sockets();
-		if (uwsgi.master_process) {
-			close(uwsgi.shared->spooler_signal_pipe[0]);
-			for(i=1;i<=uwsgi.numproc;i++) {
-				if (uwsgi.signal_pipe[i][0] != -1) {
-					close(uwsgi.signal_pipe[i][0]);
-				}
-			}
-		}
 
 		for (i = 0; i < 0xFF; i++) {
                 	if (uwsgi.p[i]->post_fork) {
@@ -74,9 +55,6 @@ pid_t spooler_start() {
 		spooler();
 	}
 	else if (pid > 0) {
-		if (uwsgi.master_process) {
-			close(uwsgi.shared->spooler_signal_pipe[1]);
-		}
 		uwsgi_log("spawned the uWSGI spooler on dir %s with pid %d\n", uwsgi.spool_dir, pid);
 	}
 
@@ -425,16 +403,29 @@ void spooler_manage_task(char *dir, char *task) {
 
 			close(spool_fd);
 
+			if (uwsgi.spooler_chdir) {
+				if (chdir(uwsgi.spooler_chdir)) {
+					uwsgi_error("chdir()");
+				}
+			}
+
+			int callable_found = 0;
 			for(i=0;i<0xff;i++) {
 				if (uwsgi.p[i]->spooler) {
 					time_t now = time(NULL);
+					if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+                        			set_spooler_harakiri(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI]);
+                			}
 					ret = uwsgi.p[i]->spooler(task, spool_buf, uh.pktsize, body, body_len);
+					if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+                        			set_spooler_harakiri(0);
+                			}
 					if (body) {
 						free(body);
 					}
 					if (ret == 0) continue;
+					callable_found = 1;
 					if (ret == -2) {
-
 						uwsgi_log("done with task/spool %s after %d seconds\n", task, time(NULL)-now);
 						destroy_spool(dir, task);	
 					}
@@ -442,6 +433,9 @@ void spooler_manage_task(char *dir, char *task) {
 					break;	
 				}
 			}
+			if (!callable_found) {
+				uwsgi_log("unable to find the spooler function, have you loaded it into the spooler process ?\n");
+			}
 
 		}
 	}

subscription.c

@@ -0,0 +1,274 @@
+#include "uwsgi.h"
+
+/*
+
+	subscription subsystem
+
+	each subscription slot is as an auto-optmizing linked list. Originally it was a uwsgi_dict (now removed from uWSGI) but this
+	would have not be able to support regexp as keys.
+
+	each slot has another circular linked list containing the nodes names
+
+	the structure and system is very similar to uwsgi_dyn_dict already used by the mime type parser
+
+	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.
+
+*/
+
+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;
+
+	if (keylen > 0xff) return NULL;
+
+	while(current_slot) {
+#ifdef UWSGI_PCRE
+		if (regexp) {
+			if (uwsgi_regexp_match(current_slot->pattern, current_slot->pattern_extra, key, keylen) >= 0) {
+				return current_slot;
+			}
+		}
+		else {
+#endif
+			if (!uwsgi_strncmp(key, keylen, current_slot->key, current_slot->keylen)) {
+                		// auto optimization
+                        	if (current_slot->prev) {
+                                        if (current_slot->hits > current_slot->prev->hits) {
+                                                struct uwsgi_subscribe_slot *slot_parent = current_slot->prev->prev, *slot_prev = current_slot->prev;
+                                                if (slot_parent) {
+                                                       slot_parent->next = current_slot;
+                                                }
+						else {
+							*slot = current_slot;
+						}
+
+                                                slot_prev->prev = current_slot;
+                                                slot_prev->next = current_slot->next;
+
+                                                current_slot->next = slot_prev;
+						current_slot->prev = slot_parent;
+
+                        		}
+                        	}
+				return current_slot;
+			}
+#ifdef UWSGI_PCRE
+		}
+#endif
+		current_slot = current_slot->next;
+	}
+
+        return NULL;
+}
+
+struct uwsgi_subscribe_node *uwsgi_get_subscribe_node(struct uwsgi_subscribe_slot **slot, char *key, uint16_t keylen, int regexp) {
+
+	if (keylen > 0xff) return NULL;
+
+	struct uwsgi_subscribe_slot *current_slot = uwsgi_get_subscribe_slot(slot, key, keylen, regexp);
+	uint64_t rr_pos = 0;
+
+	if (current_slot) {
+		// node found, move up in the list increasing hits
+		current_slot->hits++;
+		struct uwsgi_subscribe_node *node = current_slot->nodes;
+		while(node) {
+			if (rr_pos == current_slot->rr) {
+				current_slot->rr++;
+				return node;
+			}
+			node = node->next;
+			rr_pos++;
+		}
+		current_slot->rr = 0;
+		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 *a_node;
+	struct uwsgi_subscribe_slot *node_slot = node->slot;
+	struct uwsgi_subscribe_slot *prev_slot = node_slot->prev;
+	struct uwsgi_subscribe_slot *next_slot = node_slot->next;
+
+	// over-engineering to avoid race conditions
+	node->len = 0;
+
+	if (node == node_slot->nodes) {
+		node_slot->nodes = node->next;
+	}
+	else {
+		a_node = node_slot->nodes;
+		while(a_node) {
+			if (a_node->next == node) {
+				a_node->next = node->next;
+				break;
+			}
+			a_node = a_node->next;
+		}
+	}
+
+	free(node);
+	// no more nodes, remove the slot too
+	if (node_slot->nodes == NULL) {
+			
+		if (prev_slot) {	
+			prev_slot->next = next_slot;	
+		}
+		if (next_slot) {
+			next_slot->prev = prev_slot;
+		}
+
+#ifdef UWSGI_PCRE
+		if (node_slot->pattern) {
+			pcre_free(node_slot->pattern);
+		}
+		if (node_slot->pattern_extra) {
+			pcre_free(node_slot->pattern_extra);
+		}
+#endif
+
+		free(node_slot);
+		// am i the only slot ?
+		if (!prev_slot && !next_slot) {
+			*slot = NULL;
+		}
+	}
+}
+
+struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slot **slot, struct uwsgi_subscribe_req *usr, int regexp) {
+
+	struct uwsgi_subscribe_slot *current_slot = uwsgi_get_subscribe_slot(slot, usr->key, usr->keylen, 0), *old_slot = NULL, *a_slot;
+	struct uwsgi_subscribe_node *node, *old_node = NULL;
+
+	if (usr->address_len > 0xff) return NULL;
+
+        if (current_slot) {
+		node = current_slot->nodes;
+		while(node) {
+                        if (!uwsgi_strncmp(node->name, node->len, usr->address, usr->address_len)) {
+                                node->last_check = time(NULL);
+                                return node;
+                        }
+			old_node = node;
+			node = node->next;
+                }
+
+		node = uwsgi_malloc(sizeof(struct uwsgi_subscribe_node));
+		node->len = usr->address_len;
+		node->modifier1 = usr->modifier1;
+		node->modifier2 = usr->modifier2;
+		node->last_check = time(NULL);
+		node->slot = current_slot;
+                memcpy(node->name, usr->address, usr->address_len);
+		if (old_node) {
+			old_node->next = node;
+		}
+		node->next = NULL;
+                uwsgi_log("[uwsgi-subscription] %.*s => new node: %.*s\n", usr->keylen, usr->key, usr->address_len, usr->address);
+                return node;
+        }
+        else {
+
+		current_slot = uwsgi_malloc(sizeof(struct uwsgi_subscribe_slot));
+		current_slot->keylen = usr->keylen;
+		memcpy(current_slot->key, usr->key, usr->keylen);
+		current_slot->key[usr->keylen] = 0;
+		current_slot->hits = 0;
+		current_slot->rr = 0;
+
+#ifdef UWSGI_PCRE
+		current_slot->pattern = NULL;
+		current_slot->pattern_extra = NULL;
+		if (regexp) {
+			if (uwsgi_regexp_build(current_slot->key, &current_slot->pattern, &current_slot->pattern_extra)) {
+				free(current_slot);
+				return NULL;
+			}
+		}
+#endif
+
+		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->modifier1 = usr->modifier1;
+		current_slot->nodes->modifier2 = usr->modifier2;
+		memcpy(current_slot->nodes->name, usr->address, usr->address_len);
+		current_slot->nodes->last_check = time(NULL);
+
+		current_slot->nodes->next = NULL;
+
+#ifdef UWSGI_PCRE
+		// if key is a regexp, order it by keylen
+		if (regexp) {
+			old_slot = NULL;
+			a_slot = *slot;
+			while(a_slot) {
+				if (a_slot->keylen > current_slot->keylen) {
+					old_slot = a_slot;
+					break;
+				}	
+				a_slot = a_slot->next;
+			}
+
+			if (old_slot) {
+				current_slot->prev = old_slot->prev;
+				old_slot->prev = current_slot;
+				if (current_slot->prev) {
+					old_slot->prev->next = current_slot;
+				}
+	
+				current_slot->next = old_slot;
+			}
+			else {
+				a_slot = *slot;
+                        	while(a_slot) {
+                                	old_slot = a_slot;
+                                	a_slot = a_slot->next;
+                        	}
+
+
+                        	if (old_slot) {
+                                	old_slot->next = current_slot;
+                        	}
+
+                        	current_slot->prev = old_slot;
+                        	current_slot->next = NULL;
+			}
+		}
+		else {
+#endif
+			a_slot = *slot;
+			while(a_slot) {
+				old_slot = a_slot;
+				a_slot = a_slot->next;
+			}
+
+
+			if (old_slot) {
+				old_slot->next = current_slot;
+			}
+
+			current_slot->prev = old_slot;
+			current_slot->next = NULL;
+
+#ifdef UWSGI_PCRE
+		}
+#endif
+
+		if (!*slot || current_slot->prev == NULL) {
+			*slot = current_slot;
+		}
+
+		uwsgi_log("[uwsgi-subscription] new pool: %.*s\n", usr->keylen, usr->key);
+		uwsgi_log("[uwsgi-subscription] %.*s => new node: %.*s\n", usr->keylen, usr->key, usr->address_len, usr->address);
+                return current_slot->nodes;
+        }
+
+}
+
+

uwsgi.h

@@ -8,9 +8,13 @@ extern "C" {
 
 #define UMAX16	65536
 
+#define UMAX64_STR "18446744073709551616"
+
 #define uwsgi_error(x)  uwsgi_log("%s: %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
 #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__,\
+				wsgi_req->method_len, wsgi_req->method, wsgi_req->uri_len, wsgi_req->uri, wsgi_req->remote_addr_len, wsgi_req->remote_addr); else uwsgi_log_verbose("%s %s [%s line %d] \n",x, strerror(errno), __FILE__, __LINE__);
 #define uwsgi_debug(x, ...) uwsgi_log("[uWSGI DEBUG] " x, __VA_ARGS__);
 #define uwsgi_rawlog(x) if (write(2, x, strlen(x)) != strlen(x)) uwsgi_error("write()")
 #define uwsgi_str(x) uwsgi_concat2(x, "")
@@ -26,6 +30,8 @@ extern "C" {
 #define thunder_lock if (uwsgi.threads > 1) {pthread_mutex_lock(&uwsgi.thunder_mutex);}
 #define thunder_unlock if (uwsgi.threads > 1) {pthread_mutex_unlock(&uwsgi.thunder_mutex);}
 
+#define uwsgi_check_scheme(file) (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) || !uwsgi_startswith(file, "fd://", 5))
+
 #define ushared uwsgi.shared
 
 #define MAX_APPS 64
@@ -33,7 +39,6 @@ extern "C" {
 #define MAX_RPC 64
 #define MAX_GATEWAYS 64
 #define MAX_DAEMONS 8
-#define MAX_SUBSCRIPTIONS 8
 #define MAX_CRONS 64
 
 #ifndef UWSGI_LOAD_EMBEDDED_PLUGINS
@@ -112,6 +117,9 @@ extern char UWSGI_EMBED_CONFIG_END;
 
 #include <stdarg.h>
 #include <errno.h>
+#ifndef __USE_ISOC99
+#define __USE_ISOC99
+#endif
 #include <ctype.h>
 #include <sys/time.h>
 #include <unistd.h>
@@ -145,10 +153,10 @@ extern char UWSGI_EMBED_CONFIG_END;
 #include <sys/reg.h>
 #endif
 extern int pivot_root(const char *new_root, const char *put_old);
-#else
-#include <limits.h>
 #endif
 
+#include <limits.h>
+
 #include <dirent.h>
 
 #ifdef UWSGI_SCTP
@@ -222,6 +230,10 @@ extern int pivot_root(const char *new_root, const char *put_old);
 #include <sys/event.h>
 #endif
 
+#ifdef UWSGI_CAP
+#include <sys/capability.h>
+#endif
+
 #ifdef __HAIKU__
 #include <kernel/OS.h>
 #endif
@@ -278,9 +290,23 @@ struct uwsgi_string_list {
 
 	char *value;
 	size_t len;
+	uint64_t custom;
 	struct uwsgi_string_list *next;
 };
 
+struct uwsgi_dyn_dict {
+
+	char *key;
+	int keylen;
+	char *value;
+	int vallen;
+
+	uint64_t hits;
+
+	struct uwsgi_dyn_dict *prev;
+	struct uwsgi_dyn_dict *next;
+};
+
 
 union uwsgi_sockaddr {
 	struct sockaddr sa;
@@ -486,6 +512,31 @@ struct uwsgi_opt {
 #define LONG_ARGS_FASTCGI_SOCKET	17133
 #define LONG_ARGS_THREADS_STACKSIZE	17134
 #define LONG_ARGS_EMPEROR_THROTTLE	17135
+#define LONG_ARGS_STOP			17136
+#define LONG_ARGS_RELOAD		17137
+#define LONG_ARGS_REGEXP_MOUNT		17138
+#define LONG_ARGS_MIMEFILE		17139
+#define LONG_ARGS_CHEAPER		17140
+#define LONG_ARGS_CAP			17141
+#define LONG_ARGS_STATS			17142
+#define LONG_ARGS_MULE			17143
+#define LONG_ARGS_LOG_MAXSIZE		17144
+#define LONG_ARGS_LOG_BACKUPNAME	17145
+#define LONG_ARGS_EVIL_RELOAD_ON_AS	17146
+#define LONG_ARGS_EVIL_RELOAD_ON_RSS	17147
+#define LONG_ARGS_SPOOLER_HARAKIRI	17148
+#define LONG_ARGS_MULE_HARAKIRI		17149
+#define LONG_ARGS_EMPEROR_STATS		17150
+#define LONG_ARGS_SPOOLER_CHDIR		17151
+#define LONG_ARGS_LOCKS			17152
+#define LONG_ARGS_PROCNAME_PREFIX	17153
+#define LONG_ARGS_PROCNAME_APPEND	17154
+#define LONG_ARGS_PROCNAME		17155
+#define LONG_ARGS_PROCNAME_MASTER	17156
+#define LONG_ARGS_FARM			17157
+#define LONG_ARGS_MULES			17158
+#define LONG_ARGS_PROCNAME_PREFIX_SP	17159
+#define LONG_ARGS_UMASK			17160
 
 
 #define UWSGI_OK	0
@@ -524,6 +575,8 @@ struct uwsgi_opt {
 #define UWSGI_OPTION_LOG_SENDFILE	14
 #define UWSGI_OPTION_BACKLOG_STATUS	15
 #define UWSGI_OPTION_BACKLOG_ERRORS	16
+#define UWSGI_OPTION_SPOOLER_HARAKIRI   17
+#define UWSGI_OPTION_MULE_HARAKIRI	18
 
 #define UWSGI_MODIFIER_ADMIN_REQUEST		10
 #define UWSGI_MODIFIER_SPOOL_REQUEST		17
@@ -582,6 +635,8 @@ struct uwsgi_socket {
 	int disabled;
 
 	struct uwsgi_socket *next;
+	int shared;
+	int from_shared;
 };
 
 struct uwsgi_server;
@@ -605,7 +660,8 @@ struct uwsgi_plugin {
 	void (*init_apps) (void);
 	void (*fixup) (void);
 	void (*master_fixup) (int);
-	int (*mount_app) (char *, char *);
+	void (*master_cycle) (void);
+	int (*mount_app) (char *, char *, int);
 	int (*manage_udp) (char *, int, char *, int);
 	int (*manage_xml) (char *, char *);
 	void (*suspend) (struct wsgi_request *);
@@ -623,14 +679,23 @@ struct uwsgi_plugin {
 
 	int (*spooler) (char *, char *, uint16_t, char *, size_t);
 
-	 uint16_t(*rpc) (void *, uint8_t, char **, char *);
+	uint16_t(*rpc) (void *, uint8_t, char **, char *);
 
 	void (*jail) (int (*)(void *), char **);
 
+	int (*mule)(char *);
+	int (*mule_msg)(char *, size_t);
 	struct uwsgi_help_item *help;
 
 };
 
+#ifdef UWSGI_PCRE
+#include <pcre.h>
+int uwsgi_regexp_build(char *re, pcre **pattern, pcre_extra **pattern_extra);
+int uwsgi_regexp_match(pcre *pattern, pcre_extra *pattern_extra, char *subject, int length);
+#endif
+
+
 
 struct uwsgi_app {
 
@@ -639,6 +704,11 @@ struct uwsgi_app {
 	char *mountpoint;
 	int mountpoint_len;
 
+#ifdef UWSGI_PCRE
+	pcre *pattern;
+        pcre_extra *pattern_extra;
+#endif
+	
 	void *interpreter;
 	void *callable;
 
@@ -673,6 +743,7 @@ struct uwsgi_app {
         void *uwsgi_version;
         void *uwsgi_node;
 
+	uint64_t avg_response_time;
 };
 
 
@@ -763,6 +834,7 @@ struct wsgi_request {
 
 	char *path_info;
 	uint16_t path_info_len;
+	int path_info_pos;
 
 	char *script;
 	uint16_t script_len;
@@ -901,37 +973,78 @@ struct uwsgi_signal_rb_timer {
 struct uwsgi_server {
 
 
+	// store the machine hostname
 	char hostname[256];
 	int hostname_len;
+
+	char **orig_argv;
+	char **argv;
+	int argc;
+	int max_procname;
+	int auto_procname;
+	char **environ;
+	char *procname_prefix;
+	char *procname_append;
+	char *procname_master;
+	char *procname;
+
+	// quiet startup
 	int no_initial_output;
+
+	// enable threads
 	int has_threads;
+
+	// default app id
 	int default_app;
 
 	char *logto2;
 
+	// autoload plugins
 	int autoload;
 
 	int snapshot;
+
+	// enable auto-snapshotting
 	int auto_snapshot;
 	pid_t restore_snapshot;
+
+
 	int respawn_workers;
 	unsigned int reloads;
+
+	// leave master running as root
 	int master_as_root;
+	// kill the stack on SIGTERM (instead of brutal reloading)
 	int die_on_term;
 
+	// disable fd passing on unix socket
 	int no_fd_passing;
 
+	// store the current time
 	time_t current_time;
+
 	uint64_t master_cycles;
 
 	int reuse_port;
 
+	// enable lazy mode
 	int lazy;
+	// enable cheap mode
 	int cheap;
+	// enable cheaper mode
+	int cheaper;
+	// minimal number of running workers in cheaper mode
+	int cheaper_count;
+	// enable idle mode
 	int idle;
 	
+	// destroy the stack when idle
 	int die_on_idle;
 
+	// store the screen session
+	char *screen_session;
+
+	// true if run under the emperor
 	int has_emperor;
 	int emperor_fd;
 	int emperor_tyrant;
@@ -942,50 +1055,77 @@ struct uwsgi_server {
 	pid_t emperor_pid;
 	int	emperor_broodlord;
 	int	emperor_broodlord_count;
+	char *emperor_stats;
+	int 	emperor_stats_fd;
 	struct uwsgi_config_template *vassals_templates;
+	// true if loyal to the emperor
 	int loyal;
 
+	// amqp support
 	char *emperor_amqp_vhost;
 	char *emperor_amqp_username;
 	char *emperor_amqp_password;
 
+	// emperor hook (still in development)
 	char *vassals_start_hook;
 	char *vassals_stop_hook;
 
 	struct uwsgi_string_list *additional_headers;
 
+	// maximum time to wait after a reload
 	time_t master_mercy;
 
+	// set cpu affinity
 	int cpu_affinity;
 
 	int reload_mercy;
+	// map reloads to death
 	int exit_on_reload;
+
+	// store options
 	int option_index;
 	struct option *long_options;
 	struct uwsgi_opt **exported_opts;
 	int exported_opts_cnt;
+
+	// dump the whole set of options
 	int dump_options;
+	// show ini representation of the current config
 	int show_config;
+
 	//base for all the requests(even on async mode)
 	struct wsgi_request **wsgi_requests;
 	struct wsgi_request *wsgi_req;
 
 	char *remap_modifier;
 
+	// enable zerg mode
 	int *zerg;
 	char *zerg_server;
 	int zerg_server_fd;
 
+	// security
 	char *chroot;
 	gid_t gid;
 	uid_t uid;
 	char *uidname;
 	char *gidname;
 
+#ifdef UWSGI_CAP
+	cap_value_t *cap;
+	int cap_count;
+#endif
+
+	// still working on it
 	char *profiler;
+
+	// mostly useless
 	char *mode;
 
+	// binary path the worker image
 	char *worker_exec;
+
+	// gateways
 	struct uwsgi_gateway gateways[MAX_GATEWAYS];
 	int gateways_cnt;
 
@@ -993,13 +1133,22 @@ struct uwsgi_server {
 	int ignore_script_name;
 	int manage_script_name;
 	int no_default_app;
+
 	int logdate;
 	int log_micros;
 	char *log_strftime;
+	int log_x_forwarded_for;
 
 	int honour_stdin;
 
+	// route all of the logs to the master process
 	int log_master;
+
+	int log_reopen;
+	int log_truncate;
+	off_t log_maxsize;
+	char *log_backupname;
+
 	int log_syslog;
 	int original_log_fd;
 
@@ -1008,15 +1157,21 @@ struct uwsgi_server {
 	union uwsgi_sockaddr *log_socket_addr;
 	socklen_t log_socket_size;
 
+
+	// 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_dyn_dict *mimetypes;
 
 	char *logfile;
 	int logfile_chown;
 
+	// enable vhost mode
 	int vhost;
 	int vhost_host;
 
@@ -1024,6 +1179,7 @@ struct uwsgi_server {
 	char **async_buf;
 	char **async_post_buf;
 
+	// async commodity
 	struct wsgi_request **async_waiting_fd_table;
 	struct wsgi_request **async_proto_fd_table;
 	struct uwsgi_async_request *async_runqueue;
@@ -1040,19 +1196,27 @@ struct uwsgi_server {
 	int **async_ovector;
 #endif
 
+	// store rlimit
 	struct rlimit rl;
 	size_t limit_post;
+
+	// set process priority
 	int prio;
 
-	int reload_on_as;
-	int reload_on_rss;
-	char *touch_reload;
-	time_t last_touch_reload_mtime;
+	// funny reload systems
+	int force_get_memusage;
+	rlim_t reload_on_as;
+	rlim_t reload_on_rss;
+	rlim_t evil_reload_on_as;
+	rlim_t evil_reload_on_rss;
+	struct uwsgi_string_list *touch_reload;
 
 	int propagate_touch;
 
+	// enable grunt mode
 	int grunt;
 
+	// store the binary path
 	char *binary_path;
 
 	int is_a_reload;
@@ -1068,6 +1232,7 @@ struct uwsgi_server {
 
 #ifdef UWSGI_SPOOLER
 	char *spool_dir;
+	char *spooler_chdir;
 	int spooler_ordered;
 	uint64_t spooler_respawned;
 #endif
@@ -1087,6 +1252,7 @@ struct uwsgi_server {
 
 	int buffer_size;
 
+	// post buffering
 	int post_buffering;
 	int post_buffering_harakiri;
 	int post_buffering_bufsize;
@@ -1094,6 +1260,7 @@ struct uwsgi_server {
 	int master_process;
 	int master_queue;
 
+	// mainly iseful for broodlord mode
 	int vassal_sos_backlog;
 
 	int no_defer_accept;
@@ -1118,10 +1285,12 @@ struct uwsgi_server {
 	int max_vars;
 	int vec_size;
 
+	// shared area
 	char *sharedarea;
 	uint64_t sharedareasize;
 
 #ifdef UWSGI_THREADING
+	// avoid thundering herd in threaded modes
 	pthread_mutex_t six_feet_under_lock;
 #endif
 
@@ -1129,12 +1298,19 @@ struct uwsgi_server {
 	/* the list of workers */
 	struct uwsgi_worker *workers;
 
-	/* the dedicated signal_pipe */
-	int **signal_pipe;
+	/* the list of mules */
+	struct uwsgi_string_list *mules_patches;
+	struct uwsgi_mule *mules;
+	struct uwsgi_string_list *farms_list;
+	struct uwsgi_farm *farms;
 
 	pid_t mypid;
 	int mywid;
 
+	int muleid;
+	int mules_cnt;
+	int farms_cnt;
+
 	rlim_t max_fd;
 
 	struct timeval start_tv;
@@ -1205,6 +1381,7 @@ struct uwsgi_server {
 
 	char *cwd;
 
+	// conditional logging
 	int log_slow_requests;
 	int log_zero_headers;
 	int log_empty_body;
@@ -1306,6 +1483,10 @@ struct uwsgi_server {
 	int cache_server_fd;
 	pthread_mutex_t cache_server_lock;
 
+	// the stats server
+	char *stats;
+	int stats_fd;
+
 	uint64_t queue_size;
 	uint64_t queue_blocksize;
 	void *queue;
@@ -1316,9 +1497,11 @@ struct uwsgi_server {
 
 	pthread_mutex_t thunder_mutex;
 
+	int locks;
+
 	void *cache_lock;
 	void *queue_lock;
-	void *user_lock;
+	void **user_lock;
 	void *signal_table_lock;
 	void *fmon_table_lock;
 	void *timer_table_lock;
@@ -1335,8 +1518,8 @@ struct uwsgi_server {
 	char *startup_daemons[MAX_DAEMONS];
 	int startup_daemons_cnt;
 
-	char *subscriptions[MAX_SUBSCRIPTIONS];
-	int subscriptions_cnt;
+	// subscription client
+	struct uwsgi_string_list *subscriptions;
 
 };
 
@@ -1435,6 +1618,7 @@ struct uwsgi_shared {
 #ifdef UWSGI_SPOOLER
 	pid_t spooler_pid;
 	int spooler_frequency;
+	time_t spooler_harakiri;
 #endif
 
 #ifdef UWSGI_SNMP
@@ -1456,6 +1640,9 @@ struct uwsgi_shared {
 #ifdef UWSGI_SPOOLER
 	int spooler_signal_pipe[2];
 #endif
+	int mule_signal_pipe[2];
+	int mule_queue_pipe[2];
+
 	struct uwsgi_signal_entry signal_table[256];
 
 	struct uwsgi_fmon files_monitored[64];
@@ -1526,8 +1713,7 @@ struct uwsgi_worker {
 	uint64_t vsz_size;
 	uint64_t rss_size;
 
-	double running_time;
-	double last_running_time;
+	uint64_t running_time;
 
 	int manage_next_request;
 
@@ -1538,9 +1724,64 @@ struct uwsgi_worker {
 	int apps_cnt;
 	struct uwsgi_app apps[MAX_APPS];
 
+	uint64_t tx;
+
+	int busy;
+	int cheaped;
+        int sig;
+	uint8_t signum;
+
+	// signals managed by this worker
+        uint64_t signals;
+
+	int signal_pipe[2];
+
+	uint64_t avg_response_time;
+
+	char name[0xff];
 };
 
 
+struct uwsgi_mule {
+	int id;
+	pid_t pid;
+
+	int signal_pipe[2];
+	int queue_pipe[2];
+
+	time_t last_spawn;
+	uint64_t respawn_count;
+
+	char *patch;
+
+	// signals managed by this mule
+	uint64_t signals;
+	int sig;
+        uint8_t signum;
+
+	time_t harakiri;
+
+	char name[0xff];
+};
+
+struct uwsgi_mule_farm {
+	struct uwsgi_mule *mule;
+	struct uwsgi_mule_farm *next;
+};
+
+struct uwsgi_farm {
+	int id;
+	char name[0xff];
+
+	int signal_pipe[2];
+	int queue_pipe[2];
+
+	struct uwsgi_mule_farm *mules;
+
+};
+
+
+
 char *uwsgi_get_cwd(void);
 
 void warn_pipe(void);
@@ -1567,7 +1808,7 @@ void daemonize(char *);
 void logto(char *);
 
 void log_request(struct wsgi_request *);
-void get_memusage(void);
+void get_memusage(uint64_t *, uint64_t *);
 void harakiri(void);
 
 void stats(int);
@@ -1590,6 +1831,8 @@ pid_t spooler_start(void);
 #endif
 
 void set_harakiri(int);
+void set_mule_harakiri(int);
+void set_spooler_harakiri(int);
 void inc_harakiri(int);
 
 #ifdef __BIG_ENDIAN__
@@ -1708,7 +1951,7 @@ char *uwsgi_concat4n(char *, int, char *, int, char *, int, char *, int);
 int uwsgi_get_app_id(char *, int, int);
 char *uwsgi_strncopy(char *, int);
 
-void master_loop(char **, char **);
+int master_loop(char **, char **);
 
 
 int find_worker_id(pid_t);
@@ -1910,33 +2153,12 @@ struct uwsgi_dict {
 
 	void *data;
 	void *lock;
+
+	uint64_t count;
+
 	struct uwsgi_dict_item *items;
 };
 
-#define SUBSCRIBER_PAGESIZE 4096
-#define SUBSCRIBER_NODES (SUBSCRIBER_PAGESIZE/128)-4
-
-struct uwsgi_subscriber_name {
-	uint16_t len;
-	char name[128];
-
-	uint8_t modifier1;
-	uint8_t modifier2;
-
-	// total requests managed by this node
-	uint64_t	requests;
-	// bytes transferred by this node
-	uint64_t	transferred;
-
-};
-
-struct uwsgi_subscriber {
-	uint64_t nodes;
-	uint64_t current;
-	// support upto md5
-	char auth[32];
-	struct uwsgi_subscriber_name names[SUBSCRIBER_NODES];
-};
 
 struct uwsgi_subscribe_req {
 	char *key;
@@ -1952,13 +2174,6 @@ struct uwsgi_subscribe_req {
 	uint8_t modifier2;
 };
 
-struct uwsgi_dict *uwsgi_dict_create(uint64_t, uint64_t);
-void uwsgi_add_subscriber(struct uwsgi_dict *, struct uwsgi_subscribe_req *);
-char *uwsgi_dict_get(struct uwsgi_dict *, char *, uint16_t, uint64_t *);
-int uwsgi_dict_set(struct uwsgi_dict *, char *, uint16_t, char *, uint64_t);
-
-struct uwsgi_subscriber_name *uwsgi_get_subscriber(struct uwsgi_dict *, char *, uint16_t);
-
 #ifndef _NO_UWSGI_RB
 #include "lib/rbtree.h"
 
@@ -2115,6 +2330,7 @@ socklen_t socket_to_in_addr(char *, char *, struct sockaddr_in *);
 socklen_t socket_to_un_addr(char *, struct sockaddr_un *);
 
 int uwsgi_get_shared_socket_fd_by_num(int);
+struct uwsgi_socket *uwsgi_get_shared_socket_by_num(int);
 
 int uwsgi_get_shared_socket_num(struct uwsgi_socket *);
 
@@ -2157,6 +2373,82 @@ char *uwsgi_str_contains(char *, int, char);
 
 int uwsgi_simple_parse_vars(struct wsgi_request *, char *, char *);
 
+void uwsgi_build_mime_dict(char *);
+struct uwsgi_dyn_dict *uwsgi_dyn_dict_new(struct uwsgi_dyn_dict **, char *, int, char *, int);
+void uwsgi_dyn_dict_del(struct uwsgi_dyn_dict *);
+
+void uwsgi_send_stats(int);
+
+void uwsgi_apply_config_pass(char symbol, char*(*)(char *) );
+
+void uwsgi_mule(int);
+
+char *uwsgi_string_get_list(struct uwsgi_string_list **, int, size_t *);
+
+void uwsgi_fixup_fds(int, int);
+
+void uwsgi_set_processname(char *);
+
+void http_url_decode(char *, uint16_t *, char *);
+
+pid_t uwsgi_fork(char *);
+
+struct uwsgi_mule *get_mule_by_id(int);
+struct uwsgi_mule_farm *uwsgi_mule_farm_new(struct uwsgi_mule_farm **, struct uwsgi_mule *);
+
+int uwsgi_farm_has_mule(struct uwsgi_farm *, int);
+struct uwsgi_farm *get_farm_by_name(char *);
+
+struct uwsgi_subscribe_slot;
+
+struct uwsgi_subscribe_node {
+
+        char name[0xff];
+        uint16_t len;
+        uint8_t modifier1;
+        uint8_t modifier2;
+
+        time_t last_check;
+
+	uint64_t requests;
+	uint64_t transferred;
+
+	struct uwsgi_subscribe_slot *slot;
+
+        struct uwsgi_subscribe_node *next;
+};
+
+struct uwsgi_subscribe_slot {
+
+        char key[0xff];
+        uint16_t keylen;
+
+#ifdef UWSGI_PCRE
+	pcre *pattern;
+	pcre_extra *pattern_extra;
+#endif
+
+        uint64_t hits;
+
+	// used for round robin
+	uint64_t rr;
+
+        struct uwsgi_subscribe_node *nodes;
+
+        struct uwsgi_subscribe_slot *prev;
+        struct uwsgi_subscribe_slot *next;
+};
+
+
+struct uwsgi_subscribe_slot *uwsgi_get_subscribe_slot(struct uwsgi_subscribe_slot **, 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 *);
+struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slot **, struct uwsgi_subscribe_req *, int);
+
+#ifdef UWSGI_CAP
+void uwsgi_build_cap(char *);
+#endif
+
 #ifdef UWSGI_AS_SHARED_LIBRARY
 int uwsgi_init(int, char **, char **);
 #endif

uwsgicc/templates/index.html

@@ -264,20 +264,36 @@ $(document).ready(function() {
 <a name="workers"></a>
 <h3>Workers</h3>
 <div class="info">
-<table width="400">
+<table width="600">
 <tr>
     <th>#</th>
     <th>pid</th>
+    <th>status</th>
     <th>requests</th>
     <th>exceptions</th>
+    <th>signals</th>
+    <th>running time</th>
+    <th>avg response time</th>
+{% if 'memory-report' in uwsgi.opt %}
+    <th>rss</th>
+    <th>vsz</th>
+{% endif %}
     <th># respawn</th>
 </tr>
 {% for w in uwsgi.workers() %}
 	<tr class="{{ loop.cycle('odd', 'even') }}">
 		<td>{{w.id}}</td>
 		<td>{{w.pid}}</td>
+		<td>{{w.status}}</td>
 		<td>{{w.requests}}</td>
 		<td>{{w.exceptions}}</td>
+		<td>{{w.signals}}</td>
+		<td>{{w.running_time/1000}}</td>
+		<td>{{w.avg_rt/1000}}</td>
+{% if 'memory-report' in uwsgi.opt %}
+		<td>{{(w.rss/1000/1000)|round(2,'floor')}}MB</td>
+		<td>{{(w.vsz/1000/1000)|round(2,'floor')}}MB</td>
+{% endif %}
 		<td>{{w.respawn_count}}</td>
 	</tr>
 {% endfor %}
@@ -294,7 +310,7 @@ $(document).ready(function() {
 <div class="info">
 {% for w in uwsgi.workers() %}
 worker {{w.id}}
-<table width="400">
+<table width="600">
 <tr>
     <th>#</th>
     <th>modifier1</th>

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '0.9.9-dev'
+uwsgi_version = '1.0-dev'
 
 import os
 import re
@@ -33,7 +33,7 @@ def binarize(name):
     return name.replace('/', '_').replace('.','_').replace('-','_')
 
 def spcall(cmd):
-    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,stderr=open('/dev/null','w'))
+    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,stderr=open('uwsgibuild.log','w'))
 
     if p.wait() == 0:
         if sys.version_info[0] > 2:
@@ -73,6 +73,8 @@ def spcall3(cmd):
 def add_o(x):
     if x == 'uwsgi':
         x = 'main'
+    elif x.endswith('.a'):
+        return x
     x = x + '.o'
     return x
 
@@ -129,7 +131,8 @@ def build_uwsgi(uc):
         objfile = file
         if objfile == 'uwsgi':
             objfile = 'main'
-        compile(' '.join(cflags), objfile + '.o', file + '.c')
+        if not objfile.endswith('.a'):
+            compile(' '.join(cflags), objfile + '.o', file + '.c')
 
     if uc.get('embedded_plugins'):
         ep = uc.get('embedded_plugins').split(',')
@@ -152,10 +155,18 @@ def build_uwsgi(uc):
                 p_cflags = cflags[:]
                 p_cflags += up.CFLAGS
 
+                try:
+                    p_cflags.remove('-Wdeclaration-after-statement')
+                except:
+                    pass
+
                 for cfile in up.GCC_LIST:
-                    compile(' '.join(p_cflags),
-                        path + '/' + cfile + '.o', path + '/' + cfile + '.c')
-                    gcc_list.append('%s/%s' % (path, cfile))
+                    if not cfile.endswith('.a'):
+                        compile(' '.join(p_cflags),
+                            path + '/' + cfile + '.o', path + '/' + cfile + '.c')
+                        gcc_list.append('%s/%s' % (path, cfile))
+                    else:
+                        gcc_list.append(cfile)
 
                 libs += up.LIBS
                 ldflags += up.LDFLAGS
@@ -207,8 +218,20 @@ class uConf(object):
         print("using profile: %s" % filename)
         if not os.path.exists(filename):
             raise Exception("profile not found !!!")
+
+        if os.path.exists('uwsgibuild.lastprofile'):
+            ulp = open('uwsgibuild.lastprofile','r')
+            last_profile = ulp.read()
+            ulp.close()
+            if last_profile != filename:
+                os.environ['UWSGI_FORCE_REBUILD'] = '1'
+
+        ulp = open('uwsgibuild.lastprofile','w')
+        ulp.write(filename)
+        ulp.close()
+
         self.config.read(filename)
-        self.gcc_list = ['utils', 'protocol', 'socket', 'logging', 'master', 'master_utils', 'emperor', 'notify',
+        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']
         # add protocols
         self.gcc_list.append('proto/base')
@@ -246,8 +269,11 @@ class uConf(object):
             
         print("detected include path: %s" % self.include_path)
 
-        gcc_major = int(gcc_version.split('.')[0])
-        gcc_minor = int(gcc_version.split('.')[1])
+        try:
+            gcc_major = int(gcc_version.split('.')[0])
+            gcc_minor = int(gcc_version.split('.')[1])
+        except:
+            raise Exception("you need a C compiler to build uWSGI")
         if (sys.version_info[0] == 2) or (gcc_major < 4) or (gcc_major == 4 and gcc_minor < 3):
             self.cflags = self.cflags + ['-fno-strict-aliasing']
         # add -fno-strict-aliasing only on python2 and gcc < 4.3
@@ -452,6 +478,9 @@ class uConf(object):
             self.ldflags.append('-shared')
             self.ldflags.append('-fPIC')
             self.cflags.append('-DUWSGI_AS_SHARED_LIBRARY')
+            if uwsgi_os == 'Darwin':
+                self.ldflags.append('-dynamiclib')
+                self.ldflags.append('-undefined dynamic_lookup')
 
         if self.get('embedded'):
             self.cflags.append('-DUWSGI_EMBEDDED')
@@ -460,7 +489,7 @@ class uConf(object):
             self.cflags.append("-DUWSGI_UDP")
 
         # re-enable after pcre fix
-        if self.get('pcreOFF'):
+        if self.get('pcre'):
             if self.get('pcre') == 'auto':
                 pcreconf = spcall('pcre-config --libs')
                 if pcreconf:
@@ -482,6 +511,10 @@ class uConf(object):
                     self.gcc_list.append('regexp')
                     self.cflags.append("-DUWSGI_PCRE")
 
+        if self.has_include('sys/capability.h'):
+            self.cflags.append("-DUWSGI_CAP")
+            self.libs.append('-lcap')
+
         has_json = False
         has_uuid = False
 
@@ -723,6 +756,12 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
     else:
         p_cflags.append("-D%s_plugin=%s_plugin" % (up.NAME, name))
 
+    try:
+        for opt in uc.config.options(name):
+            p_cflags.append('-DUWSGI_PLUGIN_%s_%s="%s"' % (name.upper(), opt.upper(), uc.config.get(name, opt, '1')))
+    except:
+        pass
+
     plugin_dest = uc.get('plugin_dir') + '/' + name + '_plugin'
 
     shared_flag = '-shared'
@@ -733,7 +772,9 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
         shared_flag = '-dynamiclib -undefined dynamic_lookup'
 
     for cfile in up.GCC_LIST:
-        if not cfile.endswith('.c') and not cfile.endswith('.cc'):
+        if cfile.endswith('.a'): 
+            gcc_list.append(cfile)
+        elif not cfile.endswith('.c') and not cfile.endswith('.cc'):
             gcc_list.append(path + '/' + cfile + '.c')
         else:
             gcc_list.append(path + '/' + cfile)
@@ -743,6 +784,14 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
     except:
         pass
 
+    try:
+        p_cflags.remove('-Wdeclaration-after-statement')
+    except:
+        pass
+
+    #for ofile in up.OBJ_LIST:
+    #    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)
 

uwsgidecorators.py

@@ -1,6 +1,12 @@
 import uwsgi
 from threading import Thread
 
+try:
+    import cPickle as pickle
+except:
+    import pickle
+
+
 if uwsgi.masterpid() == 0:
     raise Exception("you have to enable the uWSGI master process to use this module")
 
@@ -8,6 +14,7 @@ if uwsgi.opt.get('lazy'):
     raise Exception("uWSGI lazy mode is not supported by this module")
 
 spooler_functions = {}
+mule_functions = {}
 postfork_chain = []
 
 def get_free_signal():
@@ -75,6 +82,46 @@ class spoolraw(spool):
         return uwsgi.spool(arguments)
 
 
+class mulefunc(object):
+
+    def __init__(self, f):
+        if callable(f):
+            self.fname = f.__name__
+            self.mule = 0
+            mule_functions[f.__name__] = f
+        else:
+            self.mule = f
+            self.fname = None
+
+    def real_call(self, *args, **kwargs):
+        uwsgi.mule_msg(pickle.dumps(
+            {
+                'service': 'uwsgi_mulefunc',
+                'func':self.fname,
+                'args': args,
+                'kwargs': kwargs
+            }
+        ), self.mule)
+
+
+    def __call__(self, *args, **kwargs):
+
+        if not self.fname:
+            self.fname = args[0].__name__
+            mule_functions[self.fname] = args[0]
+            return self.real_call
+
+        return self.real_call(*args, **kwargs)
+
+
+def mule_msg_dispatcher(message):
+    msg = pickle.loads(message)
+    if msg['service'] == 'uwsgi_mulefunc':
+        return mule_functions[msg['func']](*msg['args'],**msg['kwargs'])
+
+uwsgi.mule_msg_hook = mule_msg_dispatcher
+
+
 class rpc(object):
 
     def __init__(self, name):
@@ -84,6 +131,68 @@ class rpc(object):
         uwsgi.register_rpc(self.name, f)
         return f
 
+class farm_loop(object):
+
+    def __init__(self, f, farm):
+        self.f = f
+        self.farm = farm
+    
+    def __call__(self):
+        if uwsgi.mule_id() == 0:
+            return
+        if not uwsgi.in_farm(self.farm):
+            return
+        while True:
+            message = uwsgi.farm_get_msg()
+            if message:
+                self.f(message)
+
+class farm(object):
+
+    def __init__(self, name=None, **kwargs):
+        self.name = name
+
+    def __call__(self, f):
+        postfork_chain.append(farm_loop(f, self.name))
+
+class mule_loop(object):
+
+    def __init__(self, f, num):
+        self.f = f
+        self.num = num
+
+    def __call__(self):
+        if uwsgi.mule_id() == self.num:
+            self.f()
+
+class mule(object):
+    def __init__(self, num):
+        self.num = num
+
+    def __call__(self, f):
+        postfork_chain.append(mule_loop(f, self.num))
+
+class mulemsg_loop(object):
+
+    def __init__(self, f, num):
+        self.f = f
+        self.num = num
+
+    def __call__(self):
+        if uwsgi.mule_id() == self.num:
+            print " i am the mule"
+            while True:
+                message = uwsgi.mule_get_msg()
+                if message:
+                    self.f(message)
+
+class mulemsg(object):
+    def __init__(self, num):
+        self.num = num
+
+    def __call__(self, f):
+        postfork_chain.append(mulemsg_loop(f, self.num))
+
 class signal(object):
 
     def __init__(self, num, **kwargs):
@@ -148,6 +257,15 @@ class filemon(object):
         uwsgi.add_file_monitor(self.num, self.fsobj)
         return f
 
+class erlang(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __call__(self, f):
+        uwsgi.erlang_register_process(self.name, f)
+        return f
+
 class lock(object):
     def __init__(self, f):
         self.f = f

welcome.ini

@@ -1,9 +1,11 @@
 [uwsgi]
-socket = :3031
+socket = :$(PORT)
 socket = /tmp/uwsgi_welcome.socket
 vacuum = true
-module = welcome
-master = true
-processes = 4
+appname = welcome
+module = %(appname)
+numproc = 4
+master = %(vacuum)
+processes = %(numproc)
 mount = /werkzeug=tests/werkzeug.py
 manage-script-name = true

welcome.py

@@ -1,5 +1,23 @@
 import uwsgi
 import os
+import gc
+import sys
+from uwsgidecorators import *
+gc.set_debug(gc.DEBUG_SAVEALL)
+
+print(os.environ)
+print(sys.modules)
+print(sys.argv)
+
+try:
+    if sys.argv[1] == 'debug':
+        DEBUG = True
+    else:
+        raise
+except:
+    DEBUG = False
+
+
 
 def xsendfile(e, sr):
     sr('200 OK', [('Content-Type', 'image/png'), ('X-Sendfile', os.path.abspath('logo_uWSGI.png'))])
@@ -25,13 +43,51 @@ routes['/logo'] = serve_logo
 routes['/config'] = serve_config
 routes['/options'] = serve_options
 
+@postfork
+def setprocname():
+    if uwsgi.worker_id() > 0:
+        uwsgi.setprocname("i am the worker %d" % uwsgi.worker_id())
+
 def application(env, start_response):
 
+    try:
+        uwsgi.mule_msg(env['REQUEST_URI'], 1)
+    except:
+        pass
+
+    req = uwsgi.workers()[uwsgi.worker_id()-1]['requests']
+
+    uwsgi.setprocname("worker %d managed %d requests" % (uwsgi.worker_id(), req))
+
+    gc.collect(2)
+    if DEBUG:
+        print(env['wsgi.input'].fileno())
+
     if routes.has_key(env['PATH_INFO']):
         return routes[env['PATH_INFO']](env, start_response)
 
     start_response('200 OK', [('Content-Type', 'text/html')])
 
+    if DEBUG:
+        print(env['wsgi.input'].fileno())
+
+    gc.collect(2)
+
+    if DEBUG:
+        print(len(gc.get_objects()))
+
+    workers = ''
+    for w in uwsgi.workers():
+        apps = '<table border="1"><tr><th>id</th><th>mountpoint</th><th>requests</th></tr>'
+        for app in w['apps']:
+            apps += '<tr><td>%d</td><td>%s</td><td>%d</td></tr>' % (app['id'], app['mountpoint'], app['requests']) 
+        apps += '</table>'
+        workers += """
+<tr>
+<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td><td>%d</td><td>%s</td>
+</tr>
+        """ % (w['id'], w['pid'], w['status'], w['running_time']/1000, w['avg_rt']/1000, w['tx'], apps)
+
     return """
 <img src="/logo"/> version %s<br/>
 <hr size="1"/>
@@ -44,7 +100,16 @@ Configuration<br/>
 Dynamic options<br/>
 <iframe src="/options"></iframe><br/>
 
-    """ % (uwsgi.version)
+<br/>
+Workers and applications<br/>
+<table border="1">
+<tr>
+<th>wid</th><th>pid</th><th>status</th><th>running time</th><th>average</th><th>tx</th><th>apps</th>
+</tr>
+%s
+</table>
+
+    """ % (uwsgi.version, workers)
 
 
 

xmlconf.c

@@ -26,7 +26,7 @@ void uwsgi_xml_config(char *filename, struct wsgi_request *wsgi_req, int app_tag
 	char *xml_content;
 	int xml_size = 0;
 
-	if (!uwsgi_startswith(filename, "http://", 7) || !uwsgi_startswith(filename, "data://", 7) || !uwsgi_startswith(filename, "sym://", 6)) {
+	if (uwsgi_check_scheme(filename)) {
 		colon = uwsgi_get_last_char(filename, '/');
 		colon = uwsgi_get_last_char(colon, ':');
 	}
@@ -129,7 +129,7 @@ void uwsgi_xml_config(char *filename, struct wsgi_request *wsgi_req, int app_tag
 					add_exported_option((char *) node->name, (char *) node->children->content, 0);
 				}
 				else {
-					add_exported_option((char *) node->name, "1", 0);
+					add_exported_option((char *) node->name, strdup("1"), 0);
 				}
 			}
 		}

yaml.c

@@ -107,7 +107,7 @@ void uwsgi_yaml_config(char *file, char *magic_table[]) {
 	char *section_asked = "uwsgi";
 	char *colon;
 
-	if (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6)) {
+	if (uwsgi_check_scheme(file)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }