various erlang fixes

.hgtags

@@ -28,3 +28,11 @@ e91bc724325e14c13b8f548c0b6a315c48a1c32a 0.9.8-rc2
 fd8477b6348faf16588106055ca59df1c488f76a 0.9.8.1
 7169ef1d68d3dab4737bcc3f9e082839e5a06cc1 0.9.8.2
 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

ChangeLog

@@ -1,3 +1,37 @@
+*** august 2011 ***
+
+ * 0.9.9 [20110829]
+
+- various spooler improvements
+- upload progress optimizations and fixes
+- new emperor mode: Tyrant
+- allows multiple --ini options
+- better binary path detection
+- gevent loop engine support
+- resolve domain names in socket logging
+- snmp fixes and reintroduction of the snmp-api
+- fixed grunt mode
+- you can specify build profile via env var UWSGI_PROFILE
+- reintroduction of string-based multiapp
+- new option --emperor-throttle
+- improved queue and sharedarea subsystems
+- uWSGI can now be built as a shared library
+- new api attribute: uwsgi.magic_table
+- improved apache2 module
+- new option --pyshell
+- allow threads in gateways
+- fastrouter improvements
+- the application list is now shared and exported to the api
+- allows setting the thread stack size
+- UWSGI_APPID for better multiapp hosting
+- better reloading in lazy mode
+- native pump support
+- various rack fixes
+- support for attaching binary data in the executable
+- new option --set
+- extreme-optimized http protocol parser
+- WSGI handler optimizations
+
 *** july 2011 ***
 
  * 0.9.8.3 [20110723]

apache2/mod_uwsgi.c

@@ -161,6 +161,7 @@ static void *uwsgi_server_config(apr_pool_t *p, server_rec *s) {
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
 	c->max_vars = 128;
+	c->script_name[0] = 0;
 
 	return c;
 }
@@ -176,6 +177,12 @@ static void *uwsgi_dir_config(apr_pool_t *p, char *dir) {
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
 	c->max_vars = 128;
+	c->script_name[0] = 0;
+	if (dir) {
+		if (strcmp(dir, "/")) {
+			strncpy(c->script_name, dir, 255);
+		}
+	}
 
 	return c;
 }
@@ -347,31 +354,13 @@ static int uwsgi_handler(request_rec *r) {
 		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "UWSGI_SCHEME", c->scheme, &pkt_size) ;
 	}
 
-	if (c->script_name[0] == '/') {
-		if (c->script_name[1] == 0) {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", c->script_name, &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
-		}
+	if (c->script_name[0] != 0) {
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", c->script_name, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
 	}
 	else {
-		if (r->path_info) {
-			if (strlen(r->path_info) <= 0) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
-			}
-			else {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", apr_pstrndup(r->pool, r->uri, (strlen(r->uri) - strlen(r->path_info) )) , &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->path_info, &pkt_size) ;
-			}
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
-		}
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
 	}
 
 

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/gevent.ini

@@ -0,0 +1,3 @@
+[uwsgi]
+inherit = default
+embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, gevent

buildconf/lib.ini

@@ -1,5 +1,5 @@
 [uwsgi]
 inherit = default
 bin_name = libuwsgi.so
-embedded_plugins = symcall
+embedded_plugins = null
 as_shared_library = true

buildconf/pypy.ini

@@ -0,0 +1,5 @@
+[uwsgi]
+inherit = default
+bin_name = libuwsgi.so
+embedded_plugins = symcall
+as_shared_library = true

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

@@ -8,7 +8,7 @@ void uwsgi_init_cache() {
 	if (!uwsgi.cache_blocksize)
                         uwsgi.cache_blocksize = UMAX16;
 
-                if (uwsgi.cache_blocksize % uwsgi.page_size != 0) {
+                if ((uwsgi.cache_blocksize * uwsgi.cache_max_items) % uwsgi.page_size != 0) {
                         uwsgi_log("invalid cache blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.cache_blocksize, uwsgi.page_size);
                         exit(1);
                 }
@@ -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/upstart/uwsgi.conf

@@ -12,4 +12,6 @@ env LOGTO=/tmp/uwsgi.log
 env BINPATH=/home/foo/uwsgi/uwsgi
 
 # --no-orphans avoid workers without master
-exec $BINPATH --no-orphans --socket :3033 --uid 1001 --gid 1001 --limit-as 256 -m simple_app --logto $LOGTO -M -p 4
+# --die-on-term could be a good idea
+exec $BINPATH --no-orphans --socket :3033 --uid 1001 --gid 1001 --limit-as 256 -w simple_app --logto $LOGTO -M -p 4
+

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'

debug.ini

@@ -0,0 +1,2 @@
+[uwsgi]
+show-config = true

decoratortest.py

@@ -10,8 +10,8 @@ import time
 
 # register rpc function helloworld
 @rpc("helloworld")
-def hello_world():
-    return "Hello World"
+def hello2():
+    return "[RPC] Hello World"
 
 # register signal 1
 @signal(1)
@@ -45,6 +45,7 @@ def tmpmodified(num):
 def a_long_task(args):
     for i in xrange(1,10):
         print("%s = %d" % ( str(args), i))
+        print(uwsgi.call('helloworld'))
         time.sleep(1)
 
 # continuosly spool a long running task
@@ -52,10 +53,12 @@ def a_long_task(args):
 def an_infinite_task(args):
     for i in xrange(1,4):
         print("infinite: %d %s" % (i, str(args)))
+        print(uwsgi.call('helloworld'))
+        uwsgi.signal(100)
         time.sleep(1)
 
 
-# spool a task after 60 seconds
+# spool a task after 5 seconds
 @spool
 def delayed_task(args):
     print("*** I am a delayed spool job. It is %s [%s]***" % (time.asctime(), str(args)))
@@ -89,7 +92,10 @@ def a_running_thread_with_args(who):
 def a_post_fork_thread():
     while True:
         time.sleep(3)
-        print("Hello from a thread in worker %d" % uwsgi.worker_id())
+        if uwsgi.i_am_the_spooler():
+            print("Hello from a thread in the spooler")
+        else:
+            print("Hello from a thread in worker %d" % uwsgi.worker_id())
 
 @postfork
 def fork_happened():
@@ -97,24 +103,29 @@ def fork_happened():
 
 @postfork
 def fork_happened2():
-    print("waiting for a signal...")
-    uwsgi.signal_wait()
-    print("signal received: %d" % uwsgi.signal_received())
+    if uwsgi.i_am_the_spooler():
+        return
+    print("worker %d is waiting for signal 100..." % uwsgi.worker_id())
+    uwsgi.signal_wait(100)
+    print("worker %d received signal %d" % (uwsgi.worker_id(), uwsgi.signal_received()))
     print("fork() has been called [2] wid: %d" % uwsgi.worker_id())
 
 @postfork
 @lock
 def locked_func():
     print("starting locked function on worker %d" % uwsgi.worker_id())
-    for i in xrange(1, 100):
-        time.sleep(0.2)
+    for i in xrange(1, 5):
+        time.sleep(1)
         print("[locked %d] waiting..." % uwsgi.worker_id())
     print("done with locked function on worker %d" % uwsgi.worker_id())
 
+print(uwsgi.call('helloworld'))
 spool_filename = a_long_task.spool({'foo':'bar'}, hello='world')
 print("spool filename = %s" % spool_filename)
 an_infinite_task.spool(foo='bar', priority=3)
-delayed_task.spool(foo2='bar2', at=time.time()+60)
+when = int(time.time())+5
+print("scheduling a delayed task at %d" % when)
+delayed_task.spool(foo2='bar2', at=when)
 a_running_thread()
 a_running_thread_with_args("uWSGI")
 uwsgi_source_file = open('uwsgi.c','r')

django/uwsgi_admin/views.py

@@ -14,10 +14,11 @@ def index(request):
 		w['load'] = (100 * (w['running_time']/1000))/total_load
 		w['last_spawn_str'] = time.ctime(w['last_spawn'])
 
-	spooler_jobs = uwsgi.spooler_jobs()
 	jobs = []
-	for j in spooler_jobs:
-		jobs.append({'file': j, 'env': uwsgi.parsefile(j)})
+        if 'spooler' in uwsgi.opt:
+	    spooler_jobs = uwsgi.spooler_jobs()
+	    for j in spooler_jobs:
+	        jobs.append({'file': j, 'env': uwsgi.parsefile(j)})
 
 	return render_to_response('uwsgi.html', {'masterpid': uwsgi.masterpid(),
 						'started_on': time.ctime(uwsgi.started_on),

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;
@@ -32,6 +34,9 @@ struct uwsgi_instance {
         int loyal;
 
         int zerg;
+	
+	uid_t uid;
+	gid_t gid;
 };
 
 
@@ -169,19 +174,26 @@ void emperor_respawn(struct uwsgi_instance *c_ui, time_t mod) {
 	uwsgi_log("reload the uwsgi instance %s\n", c_ui->name);
 }
 
-void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
+void emperor_add(char *name, time_t born, char *config, uint32_t config_size, uid_t uid, gid_t gid) {
 
 	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;
 	char *colon = NULL;
 	int i;
 
-	sleep(1);
+	usleep(uwsgi.emperor_throttle*1000);
+
+	if (uwsgi.emperor_tyrant) {
+		if (uid == 0 || gid == 0) {
+			uwsgi_log("[emperor-tyrant] invalid permissions for file %s\n", name);
+			return;
+		}
+	}
 
 	while (c_ui->ui_next) {
 		c_ui = c_ui->ui_next;
@@ -209,6 +221,8 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 
 	memcpy(n_ui->name, name, strlen(name));
 	n_ui->born = born;
+	n_ui->uid = uid;
+	n_ui->gid = gid;
 	n_ui->last_mod = born;
 	// start without loyalty
 	n_ui->last_loyal = born;
@@ -253,6 +267,24 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	}
 	else {
 
+		if (uwsgi.emperor_tyrant) {
+			uwsgi_log("[emperor-tyrant] dropping privileges to %d %d for instance %s\n", (int) uid, (int) gid, name);
+			if (setgid(gid)) {
+                                uwsgi_error("setgid()");
+                                exit(1);
+                        }
+                        if (setgroups(0, NULL)) {
+                                uwsgi_error("setgroups()");
+                                exit(1);
+                        }
+
+                        if (setuid(uid)) {
+                                uwsgi_error("setuid()");
+                                exit(1);
+                        }
+
+		}
+
 		unsetenv("UWSGI_RELOADS");
 		unsetenv("NOTIFY_SOCKET");
 
@@ -308,9 +340,9 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			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, ':');
@@ -319,29 +351,31 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			}
 		}
 		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++) {
@@ -360,7 +394,7 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 		}
 
 		// 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");
@@ -400,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);
@@ -420,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) {
@@ -517,7 +570,7 @@ reconnect:
                                         }
                                         else {
 						if (msgsize > 0) {
-                                                	emperor_add(config_file, time(NULL), config, msgsize);
+                                                	emperor_add(config_file, time(NULL), config, msgsize, 0, 0);
 						}
                                         }
 
@@ -554,13 +607,18 @@ reconnect:
 						emperor_respawn(ui_current, time(NULL));
 					}
 					else {
-						emperor_add(config_file, time(NULL), NULL, 0);
+						emperor_add(config_file, time(NULL), NULL, 0, 0, 0);
 					}
 
 					free(config_file);
 				}
 				}
 			}
+			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) {
@@ -583,7 +641,7 @@ reconnect:
 						else if (byte == 30 && uwsgi.emperor_broodlord > 0 && uwsgi.emperor_broodlord_count < uwsgi.emperor_broodlord) {
 							uwsgi_log("[emperor] going in broodlord mode: launching zergs for %s\n", ui_current->name);
 							char *zerg_name = uwsgi_concat3(ui_current->name,":","zerg");
-							emperor_add(zerg_name, time(NULL), NULL, 0);
+							emperor_add(zerg_name, time(NULL), NULL, 0, ui_current->uid, ui_current->gid);
 							free(zerg_name);
 						}
 					}
@@ -604,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")
 					) {
 
 
@@ -620,13 +679,21 @@ reconnect:
 					ui_current = emperor_get(de->d_name);
 
 					if (ui_current) {
+						// check if uid or gid are changed, in such case, sotp the instance
+						if (uwsgi.emperor_tyrant) {
+							if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+								uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n"); 
+								emperor_stop(ui_current);	
+								continue;
+							}	
+						}
 						// check if mtime is changed and the uWSGI instance must be reloaded
 						if (st.st_mtime > ui_current->last_mod) {
 							emperor_respawn(ui_current, st.st_mtime);
 						}
 					}
 					else {
-						emperor_add(de->d_name, st.st_mtime, NULL, 0);
+						emperor_add(de->d_name, st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
 					}
 				}
 			}
@@ -643,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")
 					) {
 
@@ -659,13 +727,21 @@ reconnect:
 					ui_current = emperor_get(g.gl_pathv[i]);
 
 					if (ui_current) {
+						// check if uid or gid are changed, in such case, sotp the instance
+                                                if (uwsgi.emperor_tyrant) {
+                                                        if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+                                                                uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n");
+                                                                emperor_stop(ui_current);
+                                                                continue;
+                                                        }
+                                                }
 						// check if mtime is changed and the uWSGI instance must be reloaded
 						if (st.st_mtime > ui_current->last_mod) {
 							emperor_respawn(ui_current, st.st_mtime);
 						}
 					}
 					else {
-						emperor_add(g.gl_pathv[i], st.st_mtime, NULL, 0);
+						emperor_add(g.gl_pathv[i], st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
 					}
 				}
 
@@ -729,7 +805,7 @@ reconnect:
 					}
 					else {
 						// UNSAFE
-						emperor_add(ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len);
+						emperor_add(ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len, ui_current->uid, ui_current->gid);
 						emperor_del(ui_current);
 					}
 					break;
@@ -748,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;
         			}
@@ -687,13 +689,23 @@ enum
 
 
 static int timerfd_create (clockid_t __clock_id, int __flags) {
+#ifdef __amd64__
+	return syscall(283, __clock_id, __flags);
+#elif defined(__i386__)
 	return syscall(322, __clock_id, __flags);
+#else
+	return -1;
+#endif
 }
 
 static int timerfd_settime (int __ufd, int __flags,
                             __const struct itimerspec *__utmr,
                             struct itimerspec *__otmr) {
+#ifdef __amd64__
+	return syscall(286, __ufd, __flags, __utmr, __otmr);
+#elif defined(__i386__)
 	return syscall(325, __ufd, __flags, __utmr, __otmr);
+#endif
 }
 #endif
 
@@ -765,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
 
 */
 

lock.c

@@ -46,6 +46,7 @@ void uwsgi_lock(void *lock) {
 void uwsgi_unlock(void *lock) {
 
 	pthread_mutex_unlock((pthread_mutex_t *) lock + sizeof(pthread_mutexattr_t));
+
 }
 
 void uwsgi_rwlock_init(void *lock) {

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);
@@ -318,6 +331,15 @@ void master_loop(char **argv, char **environ) {
 #endif
 	event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->worker_signal_pipe[0]);
 
+#ifdef UWSGI_SPOOLER
+	if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
+#ifdef UWSGI_DEBUG
+		uwsgi_log("adding %d to signal poll (spooler)\n", uwsgi.shared->spooler_signal_pipe[0]);
+#endif
+		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->spooler_signal_pipe[0]);
+	}
+#endif
+
 	if (uwsgi.log_master) {
 #ifdef UWSGI_DEBUG
 		uwsgi_log("adding %d to master logging\n", uwsgi.shared->worker_log_pipe[0]);
@@ -337,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);
@@ -351,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");
 	}
 
@@ -450,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++) {
@@ -463,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
@@ -476,26 +521,39 @@ void master_loop(char **argv, char **environ) {
 	}
 
 	if (uwsgi.queue_store && uwsgi.queue_filesize) {
-		if (msync(uwsgi.queue, uwsgi.queue_filesize, MS_ASYNC)) {
+		if (msync(uwsgi.queue_header, uwsgi.queue_filesize, MS_ASYNC)) {
 			uwsgi_error("msync()");
 		}
 	}
 
-	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) {
@@ -504,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++) {
@@ -519,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 {
@@ -532,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;
@@ -560,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);
 			}
 
@@ -570,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);
 			}
 
@@ -590,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) {
@@ -607,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);	
@@ -616,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);
@@ -623,6 +758,7 @@ void master_loop(char **argv, char **environ) {
 			uwsgi_error("execvp()");
 			// never here
 			exit(1);
+#endif
 		}
 
 		if (!uwsgi.cheap) {
@@ -643,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");
@@ -760,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;
@@ -846,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;
 							}
@@ -1016,23 +1168,75 @@ void master_loop(char **argv, char **environ) {
 							//uwsgi.workers[i].pipe[0] = -1;
 						}
 					}
+	
+#ifdef UWSGI_SPOOLER
+					// check for spooler signal
+				if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
+					if (interesting_fd == uwsgi.shared->spooler_signal_pipe[0]) {
+						rlen = read(interesting_fd, &uwsgi_signal, 1);
+						if (rlen < 0) {
+							uwsgi_error("read()");
+						}	
+						else if (rlen > 0) {
+#ifdef UWSGI_DEBUG
+							uwsgi_log_verbose("received uwsgi signal %d from the spooler\n", uwsgi_signal);
+#endif
+							uwsgi_route_signal(uwsgi_signal);
+						}
+						else {
+							uwsgi_log_verbose("lost connection with the spooler\n");
+							close(interesting_fd);
+						}
+					}
+				}
+#endif
+	
+
 				}
 
 			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);
 				}	
-*/
 			}
 
 				
@@ -1164,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
@@ -1179,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;
 				}
 			}
 
@@ -1194,25 +1433,26 @@ void master_loop(char **argv, char **environ) {
 			}
 
 			if (uwsgi.queue_store && uwsgi.queue_filesize && uwsgi.queue_store_sync && ((uwsgi.master_cycles % uwsgi.queue_store_sync) == 0)) {
-				if (msync(uwsgi.queue, uwsgi.queue_filesize, MS_ASYNC)) {
+				if (msync(uwsgi.queue_header, uwsgi.queue_filesize, MS_ASYNC)) {
                         		uwsgi_error("msync()");
                 		}
 			}
 
 			// 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;
 			}
 
 
@@ -1230,12 +1470,27 @@ void master_loop(char **argv, char **environ) {
 		if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
 			if (diedpid == uwsgi.shared->spooler_pid) {
 				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]);
 				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;
@@ -1276,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));
 			}
@@ -1285,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;
@@ -1315,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++;
@@ -1338,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/gevent/gevent.c

@@ -0,0 +1,356 @@
+#include "../python/uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+
+struct option gevent_options[] = {
+	{ 0, 0, 0, 0 }
+};
+
+#define GEVENT_SWITCH PyObject *gswitch = python_call(ugevent.greenlet_switch, ugevent.greenlet_switch_args, 0, NULL); Py_DECREF(gswitch)
+#define GET_CURRENT_GREENLET python_call(ugevent.get_current, ugevent.get_current_args, 0, NULL)
+#define free_req_queue uwsgi.async_queue_unused_ptr++; uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req
+#define stop_the_watchers ret = PyObject_CallMethod(timer, "stop", NULL);\
+                          if (ret) Py_DECREF(ret);\
+                          ret = PyObject_CallMethod(watcher, "stop", NULL);\
+                          if (ret) Py_DECREF(ret);
+
+struct uwsgi_gevent {
+	PyObject *greenlet_switch;
+	PyObject *greenlet_switch_args;
+	PyObject *get_current;
+	PyObject *get_current_args;
+	PyObject *hub;
+	PyObject *hub_loop;
+	PyObject *spawn;
+	PyObject *greenlet_args;
+	PyObject *signal_args;
+} ugevent;
+
+
+PyObject *py_uwsgi_gevent_signal_handler(PyObject * self, PyObject * args) {
+
+	uint8_t uwsgi_signal;
+	int signal_socket;
+
+	if (!PyArg_ParseTuple(args, "i:uwsgi_gevent_signal_handler", &signal_socket)) {
+        	return NULL;
+	}
+
+	if (read(signal_socket, &uwsgi_signal, 1) <= 0) {
+        	if (uwsgi.no_orphans) {
+                	uwsgi_log_verbose("uWSGI worker %d screams: UAAAAAAH my master died, i will follow him...\n", uwsgi.mywid);
+                        end_me(0);
+                }
+		// close the socket to end the mess...from now on the worker is alone (no master)
+                else close(signal_socket);
+        }
+        else {
+#ifdef UWSGI_DEBUG
+        	uwsgi_log_verbose("master sent signal %d to worker %d\n", uwsgi_signal, uwsgi.mywid);
+#endif
+		if (uwsgi_signal_handler(uwsgi_signal)) {
+                	uwsgi_log_verbose("error managing signal %d on worker %d\n", uwsgi_signal, uwsgi.mywid);
+                }
+        }
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *py_uwsgi_gevent_signal(PyObject * self, PyObject * args) {
+
+	PyTuple_SetItem(ugevent.signal_args, 1, PyInt_FromLong(uwsgi.signal_socket));
+
+	// spawn the signal_handler greenlet
+        PyObject *new_gl = python_call(ugevent.spawn, ugevent.signal_args, 0, NULL);
+        Py_DECREF(new_gl);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+	
+}
+
+// yes copy&paste no-DRY for me :P
+PyObject *py_uwsgi_gevent_my_signal(PyObject * self, PyObject * args) {
+
+	PyTuple_SetItem(ugevent.signal_args, 1, PyInt_FromLong(uwsgi.my_signal_socket));
+
+	// spawn the signal_handler greenlet
+        PyObject *new_gl = python_call(ugevent.spawn, ugevent.signal_args, 0, NULL);
+        Py_DECREF(new_gl);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+
+PyObject *py_uwsgi_gevent_main(PyObject * self, PyObject * args) {
+
+
+	struct wsgi_request *wsgi_req = find_first_available_wsgi_req();
+
+	if (wsgi_req == NULL) {
+		uwsgi_log("async queue is full !!!\n");
+		goto clear;
+	}
+	uwsgi.wsgi_req = wsgi_req;
+
+	// fill wsgi_request structure
+	wsgi_req_setup(wsgi_req, wsgi_req->async_id, uwsgi.sockets );
+
+	// mark core as used
+	uwsgi.core[wsgi_req->async_id]->in_request = 1;
+
+	gettimeofday(&wsgi_req->start_of_request, NULL);
+
+	// enter harakiri mode
+        if (uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {
+                set_harakiri(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI]);
+        }
+
+	// accept the connection
+	if (wsgi_req_simple_accept(wsgi_req, uwsgi.sockets->fd)) {
+		uwsgi_close_request(wsgi_req);
+		free_req_queue;
+		goto clear;
+	}
+
+	// hack to easily pass wsgi_req pointer to the greenlet
+	PyTuple_SetItem(ugevent.greenlet_args, 1, PyLong_FromLong((long)wsgi_req));
+
+	// spawn the request greenlet
+	PyObject *new_gl = python_call(ugevent.spawn, ugevent.greenlet_args, 0, NULL);
+	Py_DECREF(new_gl);
+
+clear:
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *uwsgi_gevent_wait(PyObject *watcher, PyObject *timer, PyObject *current) {
+
+	PyObject *ret;
+
+	// start the io watcher
+	ret = PyObject_CallMethod(watcher, "start", "OO", current, watcher);
+	if (!ret) return NULL;
+	Py_DECREF(ret);
+
+	// start the timeout handler
+	ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
+	if (!ret) return NULL;
+	Py_DECREF(ret);
+
+	// pass control to the hub
+	return PyObject_CallMethod(ugevent.hub, "switch", NULL);
+}
+
+PyObject *py_uwsgi_gevent_request(PyObject * self, PyObject * args) {
+
+	PyObject *ret;
+	PyObject *py_wsgi_req = PyTuple_GetItem(args, 0);
+	struct wsgi_request *wsgi_req = (struct wsgi_request *) PyLong_AsLong(py_wsgi_req);
+	int status ;
+
+	PyObject *current_greenlet = GET_CURRENT_GREENLET;
+	PyObject *greenlet_switch = PyObject_GetAttrString(current_greenlet, "switch");
+
+	uwsgi.wsgi_req = wsgi_req;
+
+	// create a watcher for request socket
+	PyObject *watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", wsgi_req->poll.fd, 1);
+	if (!watcher) goto clear1;
+
+	// a timer to implement timeoit (thanks Denis)
+	PyObject *timer = PyObject_CallMethod(ugevent.hub_loop, "timer", "i", uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+	if (!timer) goto clear0;
+
+	for(;;) {
+		// wait for data in the socket
+		PyObject *ret = uwsgi_gevent_wait(watcher, timer, greenlet_switch);
+		if (!ret) goto clear_and_stop;
+
+		// do not forget to overwrite this pointer each time !!!
+		uwsgi.wsgi_req = wsgi_req;
+
+		// we can safely decref here as watcher and timer has got a +1 for start() method
+		Py_DECREF(ret);
+		if (ret == timer) {
+			uwsgi_log( "timeout. skip request.\n");
+			goto clear_and_stop;
+		}
+		else if (ret == watcher) {
+
+			status = wsgi_req->socket->proto(wsgi_req);
+			if (status < 0) {
+				goto clear_and_stop;
+			}
+			else if (status == 0) {
+				stop_the_watchers;
+				break;
+			}
+		}
+		else {
+			uwsgi_log("unrecognized gevent event !!!\n");
+			goto clear_and_stop;
+		}
+
+		stop_the_watchers;
+	}
+
+	for(;;) {
+		uwsgi.wsgi_req = wsgi_req;
+		wsgi_req->async_status = uwsgi.p[wsgi_req->uh.modifier1]->request(wsgi_req);
+		if (wsgi_req->async_status <= UWSGI_OK) {
+			goto clear;
+		}
+		// switch after each yield
+		GEVENT_SWITCH;
+	}
+
+	goto clear;
+
+clear_and_stop:
+
+	stop_the_watchers;
+
+clear:
+	Py_DECREF(timer);
+clear0:
+	Py_DECREF(watcher);
+clear1:
+	Py_DECREF(greenlet_switch);
+	Py_DECREF(current_greenlet);
+	uwsgi_close_request(wsgi_req);
+
+	uwsgi.wsgi_req = wsgi_req;
+
+	free_req_queue;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+
+
+}
+
+PyMethodDef uwsgi_gevent_main_def[] = { {"uwsgi_gevent_main", py_uwsgi_gevent_main, METH_VARARGS, ""} };
+PyMethodDef uwsgi_gevent_request_def[] = { {"uwsgi_gevent_request", py_uwsgi_gevent_request, METH_VARARGS, ""} };
+PyMethodDef uwsgi_gevent_signal_def[] = { {"uwsgi_gevent_signal", py_uwsgi_gevent_signal, METH_VARARGS, ""} };
+PyMethodDef uwsgi_gevent_my_signal_def[] = { {"uwsgi_gevent_my_signal", py_uwsgi_gevent_my_signal, METH_VARARGS, ""} };
+PyMethodDef uwsgi_gevent_signal_handler_def[] = { {"uwsgi_gevent_signal_handler", py_uwsgi_gevent_signal_handler, METH_VARARGS, ""} };
+
+
+void gevent_loop() {
+
+	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+
+	if (uwsgi.async < 2) {
+		uwsgi_log("the gevent loop engine requires async mode (--async <n>)\n");
+		exit(1);
+	}
+
+
+	PyObject *gevent_dict = get_uwsgi_pydict("gevent");
+	if (!gevent_dict) uwsgi_pyexit;
+
+	PyObject *gevent_version = PyDict_GetItemString(gevent_dict, "version_info");
+	if (!gevent_version) uwsgi_pyexit;
+
+	if (PyInt_AsLong(PyTuple_GetItem(gevent_version, 0)) < 1) {
+		uwsgi_log("uWSGI requires at least gevent 1.x version\n");
+		exit(1);
+	}
+
+	ugevent.spawn = PyDict_GetItemString(gevent_dict, "spawn");
+	if (!ugevent.spawn) uwsgi_pyexit;
+
+	ugevent.greenlet_switch = PyDict_GetItemString(gevent_dict, "sleep");
+	if (!ugevent.greenlet_switch) uwsgi_pyexit;
+
+	ugevent.greenlet_switch_args = PyTuple_New(0);
+	Py_INCREF(ugevent.greenlet_switch_args);
+	
+
+	PyObject *gevent_get_hub = PyDict_GetItemString(gevent_dict, "get_hub");
+
+	ugevent.hub = python_call(gevent_get_hub, PyTuple_New(0), 0, NULL);
+	if (!ugevent.hub) uwsgi_pyexit;
+
+	ugevent.get_current = PyDict_GetItemString(gevent_dict, "getcurrent");
+	if (!ugevent.get_current) uwsgi_pyexit;
+
+	ugevent.get_current_args = PyTuple_New(0);
+	Py_INCREF(ugevent.get_current_args);
+	
+
+	ugevent.hub_loop = PyObject_GetAttrString(ugevent.hub, "loop");
+	if (!ugevent.hub_loop) uwsgi_pyexit;
+
+	// this is the watcher for server socket
+	PyObject *watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi_sock->fd, 1);
+	if (!watcher) uwsgi_pyexit;
+
+	// main greenlet waiting for connection
+	PyObject *uwsgi_gevent_main = PyCFunction_New(uwsgi_gevent_main_def, NULL);
+	Py_INCREF(uwsgi_gevent_main);
+
+	// greenlet to run at each request
+	PyObject *uwsgi_request_greenlet = PyCFunction_New(uwsgi_gevent_request_def, NULL);
+	Py_INCREF(uwsgi_request_greenlet);
+
+	// pre-fill the greenlet args
+	ugevent.greenlet_args = PyTuple_New(2);
+	PyTuple_SetItem(ugevent.greenlet_args, 0, uwsgi_request_greenlet);
+
+	if (uwsgi.signal_socket > -1) {
+		// and these are the watcher for signal sockets
+
+		PyObject *signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.signal_socket, 1);
+        	if (!signal_watcher) uwsgi_pyexit;
+
+		PyObject *my_signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.my_signal_socket, 1);
+        	if (!my_signal_watcher) uwsgi_pyexit;
+
+		PyObject *uwsgi_greenlet_signal = PyCFunction_New(uwsgi_gevent_signal_def, NULL);
+        	Py_INCREF(uwsgi_greenlet_signal);
+
+		PyObject *uwsgi_greenlet_my_signal = PyCFunction_New(uwsgi_gevent_my_signal_def, NULL);
+        	Py_INCREF(uwsgi_greenlet_my_signal);
+
+		PyObject *uwsgi_greenlet_signal_handler = PyCFunction_New(uwsgi_gevent_signal_handler_def, NULL);
+        	Py_INCREF(uwsgi_greenlet_signal_handler);
+
+		ugevent.signal_args = PyTuple_New(2);
+		PyTuple_SetItem(ugevent.signal_args, 0, uwsgi_greenlet_signal_handler);
+
+		// start the two signal watchers
+		if (!PyObject_CallMethod(signal_watcher, "start", "O", uwsgi_greenlet_signal)) uwsgi_pyexit;
+		if (!PyObject_CallMethod(my_signal_watcher, "start", "O", uwsgi_greenlet_my_signal)) uwsgi_pyexit;
+
+	}
+	
+	// start the main greenlet
+	PyObject_CallMethod(watcher, "start", "O", uwsgi_gevent_main);
+
+	if (!PyObject_CallMethod(ugevent.hub, "join", NULL)) {
+		PyErr_Print();
+	}
+
+	uwsgi_log("the gevent Hub is no more :(\n");
+
+}
+
+int gevent_init() {
+
+	uwsgi_register_loop( (char *) "gevent", gevent_loop);
+	return 0;
+}
+
+
+struct uwsgi_plugin gevent_plugin = {
+
+	.name = "gevent",
+	.init = gevent_init,
+	.options = gevent_options,
+};

plugins/gevent/uwsgiplugin.py

@@ -0,0 +1,8 @@
+from distutils import sysconfig
+
+NAME='gevent'
+CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True)]
+LDFLAGS = []
+LIBS = []
+
+GCC_LIST = ['gevent']

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;
 	}
 
@@ -170,8 +232,16 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		wi->mountpoint_len = strlen(wi->mountpoint);
 		wsgi_req->appid = wi->mountpoint;
 		wsgi_req->appid_len = wi->mountpoint_len;
+#ifdef UWSGI_DEBUG
 		uwsgi_log("main mountpoint = %s\n", wi->mountpoint);
+#endif
 		wi->callable = PyDict_GetItem(applications, app_mnt);
+		if (PyString_Check((PyObject *) wi->callable)) {
+			PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+			if (callables_dict) {
+				wi->callable = PyDict_GetItem(callables_dict, (PyObject *)wi->callable);	
+			}
+		}
 	}
 
 	Py_INCREF((PyObject *)wi->callable);
@@ -248,6 +318,8 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #else
 
+	// add start_response on WSGI app
+	Py_INCREF((PyObject *)up.wsgi_spitout);
 	wi->wsgi_args = PyTuple_New(wi->argc);
 	if (app_type == PYTHON_APP_TYPE_WSGI) {
 		if (PyTuple_SetItem(wi->wsgi_args, 1, up.wsgi_spitout)) {
@@ -299,16 +371,16 @@ 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) {
+	if ((wsgi_req->appid_len == 0 || (wsgi_req->appid_len = 1 && wsgi_req->appid[0] == '/')) && uwsgi.default_app == -1) {
 		uwsgi_rawlog(" (default app)");
 		uwsgi.default_app = id;
 	}
@@ -327,7 +399,19 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 
 			wsgi_req->appid = PyString_AsString(app_mnt);
 			wsgi_req->appid_len = strlen(wsgi_req->appid);
-			init_uwsgi_app(LOADER_CALLABLE, PyDict_GetItem(applications, app_mnt), wsgi_req, wi->interpreter, app_type);
+			PyObject *a_callable = PyDict_GetItem(applications, app_mnt);
+			if (PyString_Check(a_callable)) {
+
+				PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+				if (callables_dict) {
+					a_callable = PyDict_GetItem(callables_dict, a_callable);
+				}
+			}
+			if (!a_callable) {
+				uwsgi_log("skipping broken app %s\n", wsgi_req->appid);
+				continue;
+			}
+			init_uwsgi_app(LOADER_CALLABLE, a_callable, wsgi_req, wi->interpreter, app_type);
 		}
 	}
 
@@ -344,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) {
@@ -353,6 +438,7 @@ doh:
 			PyThreadState_Swap(up.main_thread);
 		}
 	}
+#endif
 	return -1;
 }
 
@@ -397,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;
 
@@ -420,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");
@@ -592,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;
@@ -647,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},
 };
@@ -71,6 +75,7 @@ struct uwsgi_help_item uwsgi_python_help[] = {
 {"file <file>", "use python file instead of python module for configuration"},
 {"eval <code>", "evaluate code for app configuration"},
 {"ini-paste <inifile>", "path of ini config file that contains paste configuration"},
+{"pyshell", "run a python interactive shell in the uwsgi environment (steals a worker)"},
 
 
  { 0, 0},
@@ -99,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;
@@ -130,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);
@@ -155,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)
@@ -174,6 +188,7 @@ void uwsgi_python_reset_random_seed() {
                         }
                 }
         }
+#endif
 }
 
 void uwsgi_python_post_fork() {
@@ -188,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");
@@ -199,6 +215,7 @@ void uwsgi_python_post_fork() {
 	}
 	PyErr_Clear();
 #endif
+#endif
 
 UWSGI_RELEASE_GIL
 
@@ -206,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;
@@ -214,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) {
@@ -291,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;
@@ -303,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) {
@@ -330,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();
 	}
@@ -456,6 +438,8 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *) &uwsgi_InputType);
+
 	up.embedded_dict = PyModule_GetDict(new_uwsgi_module);
 	if (!up.embedded_dict) {
 		uwsgi_log("could not get uwsgi module __dict__\n");
@@ -546,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);
@@ -576,6 +565,23 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	PyObject *py_magic_table = PyDict_New();
+	uint8_t mtk;
+	for (i = 0; i <= 0xff; i++) {
+		// a bit of magic :P
+		mtk = i;
+                if (uwsgi.magic_table[i]) {
+			if (uwsgi.magic_table[i][0] != 0) {
+				PyDict_SetItem(py_magic_table, PyString_FromStringAndSize((char *) &mtk, 1), PyString_FromString(uwsgi.magic_table[i]));
+			}
+		}
+        }
+
+	if (PyDict_SetItemString(up.embedded_dict, "magic_table", py_magic_table)) {
+		PyErr_Print();
+		exit(1);
+	}
+
 #ifdef UNBIT
 	if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_True)) {
 #else
@@ -654,9 +660,19 @@ void init_uwsgi_embedded_module() {
 		init_uwsgi_module_sharedarea(new_uwsgi_module);
 	}
 
-	init_uwsgi_module_cache(new_uwsgi_module);
+	if (uwsgi.cache_max_items > 0) {
+		init_uwsgi_module_cache(new_uwsgi_module);
+	}
 
-	init_uwsgi_module_queue(new_uwsgi_module);
+	if (uwsgi.queue_size > 0) {
+		init_uwsgi_module_queue(new_uwsgi_module);
+	}
+
+#ifdef UWSGI_SNMP
+	if (uwsgi.snmp) {
+		init_uwsgi_module_snmp(new_uwsgi_module);
+	}
+#endif
 
 	if (up.extension) {
 		up.extension();
@@ -723,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);
@@ -747,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':
@@ -763,12 +778,12 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 
 #ifdef UWSGI_INI
 	case LONG_ARGS_INI_PASTE:
-		uwsgi.ini = optarg;
-		if (uwsgi.ini[0] != '/') {
-			up.paste = uwsgi_concat4("config:", uwsgi.cwd, "/", uwsgi.ini);
+		uwsgi_string_new_list(&uwsgi.ini,optarg);
+		if (optarg[0] != '/') {
+			up.paste = uwsgi_concat4("config:", uwsgi.cwd, "/", optarg);
 		}
 		else {
-			up.paste = uwsgi_concat2("config:", uwsgi.ini);
+			up.paste = uwsgi_concat2("config:", optarg);
 		}
 		return 1;
 #endif
@@ -792,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;
 
 }
 
@@ -825,7 +857,7 @@ char *uwsgi_pythonize(char *orig) {
 			name[i] = '_';
 		}
 		else if (name[i] == '/') {
-			name[i] = '.';
+			name[i] = '_';
 		}
 	}
 
@@ -842,7 +874,6 @@ void uwsgi_python_spooler_init(void) {
 
 	struct uwsgi_string_list *upli = up.spooler_import_list;
 
-	
 	UWSGI_GET_GIL
 
         while(upli) {
@@ -869,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) {
@@ -984,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
 	}
 
 }
@@ -1037,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");
+	
 
 }
 
@@ -1048,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
 
 }
 
@@ -1101,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();
@@ -1115,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) {
 
@@ -1184,6 +1231,7 @@ int uwsgi_python_signal_handler(uint8_t sig, void *handler) {
 	ret = python_call(handler, args, 0, NULL);
 	Py_DECREF(args);
 	if (ret) {
+		Py_DECREF(ret);
 		UWSGI_RELEASE_GIL;
 		return 0;
 	}
@@ -1195,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;
@@ -1217,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;
 			}
 		}
@@ -1225,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;
 
@@ -1302,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();
@@ -1316,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 = {
@@ -1342,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,
@@ -1358,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,
@@ -1367,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

@@ -72,8 +72,9 @@ void init_pyargv() {
 	up.py_argv[0] = "uwsgi";
 #endif
 
-	if (up.argv != NULL && !up.argc) {
-		up.argc++;
+	up.argc = 1;
+
+	if (up.argv != NULL) {
 #ifdef PYTHREE
 		wchar_t *wcargv = malloc( sizeof( wchar_t ) * (strlen(up.argv)+1));
 		if (!wcargv) {
@@ -104,7 +105,20 @@ void init_pyargv() {
 			}
 		}
 
+#ifndef UWSGI_PYPY
 		PySys_SetArgv(up.argc, up.py_argv);
+#endif
+
+	PyObject *sys_dict = get_uwsgi_pydict("sys");
+	if (!sys_dict) {
+		uwsgi_log("unable to load python sys module !!!\n");
+		exit(1);
+	}
+#ifdef PYTHREE
+	PyDict_SetItemString(sys_dict, "executable", PyUnicode_FromString(uwsgi.binary_path));
+#else
+	PyDict_SetItemString(sys_dict, "executable", PyString_FromString(uwsgi.binary_path));
+#endif
 
 
 }

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);
@@ -351,17 +371,19 @@ clear:
 }
 
 static PyMethodDef symimporter_methods[] = {
-    {"find_module", symimporter_find_module, METH_VARARGS},
-    {"load_module", symimporter_load_module, METH_VARARGS},
+	{"find_module", symimporter_find_module, METH_VARARGS},
+ 	{"load_module", symimporter_load_module, METH_VARARGS},
+	{ NULL, NULL },
 };
 
 static PyMethodDef symzipimporter_methods[] = {
-    {"find_module", symzipimporter_find_module, METH_VARARGS},
-    {"load_module", symzipimporter_load_module, METH_VARARGS},
+	{"find_module", symzipimporter_find_module, METH_VARARGS},
+	{"load_module", symzipimporter_load_module, METH_VARARGS},
+	{ NULL, NULL },
 };
 
 static void uwsgi_symimporter_free(struct _symimporter *self) {
-        PyObject_Del(self);
+	PyObject_Del(self);
 }
 
 
@@ -404,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
@@ -422,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, ':');
         }
@@ -440,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;
         }
@@ -478,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;
         }
@@ -543,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;
@@ -556,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;
 	}
@@ -566,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;
@@ -579,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;
         }
@@ -642,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 = {
@@ -684,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 */
 };
 
 
@@ -717,6 +770,7 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *)&SymImporter_Type);
 	if (PyModule_AddObject(uwsgi_em, "SymbolsImporter",
                            (PyObject *)&SymImporter_Type) < 0) {
 		PyErr_Print();
@@ -724,6 +778,7 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *)&ZipImporter_Type);
 	if (PyModule_AddObject(uwsgi_em, "ZipImporter",
                            (PyObject *)&ZipImporter_Type) < 0) {
 		PyErr_Print();
@@ -731,6 +786,7 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *)&SymZipImporter_Type);
 	if (PyModule_AddObject(uwsgi_em, "SymbolsZipImporter",
                            (PyObject *)&SymZipImporter_Type) < 0) {
 		PyErr_Print();

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;
@@ -249,6 +253,7 @@ void init_uwsgi_module_spooler(PyObject *);
 void init_uwsgi_module_sharedarea(PyObject *);
 void init_uwsgi_module_cache(PyObject *);
 void init_uwsgi_module_queue(PyObject *);
+void init_uwsgi_module_snmp(PyObject *);
 
 PyObject *uwsgi_pyimport_by_filename(char *, char *);
 
@@ -263,8 +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,12 +22,15 @@ 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);
         }
 
-
         if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
                 wsgi_req->uh.modifier1 = 0;
                 pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
@@ -44,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
@@ -62,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);
@@ -78,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);
 	}
@@ -117,15 +128,20 @@ 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);
 
 	if (uwsgi.cores > 1) {
-		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+		zero = PyInt_FromLong(wsgi_req->async_id);
+		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", zero);
+		Py_DECREF(zero);
 	}
 
 	// cache this ?
@@ -178,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/python24/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python24'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.4-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python25/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python25'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.5-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python26/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python26'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.6-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python27/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python27'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.7-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python30/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python30'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.0-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python31/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python31'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.1-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python32/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python32'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.2-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

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

@@ -355,7 +355,7 @@ int uwsgi_parse_packet(struct wsgi_request *wsgi_req, int timeout) {
 			exit(1);
 		}
 		else if (rlen == 0) {
-			uwsgi_log( "timeout waiting for header. skip request.\n");
+			uwsgi_log( "timeout. skip request.\n");
 			//close(upoll->fd);
 			return 0;
 		}
@@ -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;
@@ -717,7 +726,7 @@ next:
 		}
                 // on tiny post use memory
                 else {
-                	if (!uwsgi_read_whole_body_in_mem(wsgi_req, uwsgi.mem_post_buf[wsgi_req->async_id], uwsgi.post_buffering)) {
+                	if (!uwsgi_read_whole_body_in_mem(wsgi_req, wsgi_req->post_buffering_buf)) {
 				wsgi_req->status = -1;
 				return -1;	
                         }
@@ -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,14 +769,17 @@ 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++) {
-				//uwsgi_log("app mountpoint = %.*s\n", uwsgi.apps[i].mountpoint_len, uwsgi.apps[i].mountpoint);
+				//uwsgi_log("app mountpoint = %.*s\n", uwsgi_apps[i].mountpoint_len, uwsgi_apps[i].mountpoint);
 				if (orig_path_info_len >= uwsgi_apps[i].mountpoint_len) {
 					if (!uwsgi_startswith(orig_path_info, uwsgi_apps[i].mountpoint, uwsgi_apps[i].mountpoint_len) && uwsgi_apps[i].mountpoint_len > best_found) {
 						best_found = uwsgi_apps[i].mountpoint_len;
@@ -779,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
@@ -1324,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) {
 
@@ -1348,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) {
@@ -1380,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] != '/') {
@@ -1396,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] != '/') {
@@ -1408,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)

queue.c

@@ -6,17 +6,15 @@ void uwsgi_init_queue() {
 	if (!uwsgi.queue_blocksize)
                         uwsgi.queue_blocksize = 8192;
 
-                if (uwsgi.queue_blocksize % uwsgi.page_size != 0) {
-                        uwsgi_log("invalid queue blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.queue_blocksize, uwsgi.page_size);
+                if ((uwsgi.queue_blocksize * uwsgi.queue_size) % uwsgi.page_size != 0) {
+                        uwsgi_log("invalid queue size/blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.queue_blocksize, uwsgi.page_size);
                         exit(1);
                 }
 
 
-                uwsgi.shared->queue_pos = 0;
-                uwsgi.shared->queue_pull_pos = 0;
 
                 if (uwsgi.queue_store) {
-                        uwsgi.queue_filesize = uwsgi.queue_blocksize * uwsgi.queue_size;
+                        uwsgi.queue_filesize = uwsgi.queue_blocksize * uwsgi.queue_size + 16;
                         int queue_fd;
                         struct stat qst;
 
@@ -45,16 +43,26 @@ void uwsgi_init_queue() {
                                 exit(1);
                         }
                         uwsgi.queue = mmap(NULL, uwsgi.queue_filesize, PROT_READ | PROT_WRITE, MAP_SHARED, queue_fd, 0);
-                        uwsgi_queue_fix();
+
+			// fix header
+			uwsgi.queue_header = uwsgi.queue;
+			uwsgi.queue+=16;
                 }
                 else {
-                        uwsgi.queue = mmap(NULL, uwsgi.queue_blocksize * uwsgi.queue_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                        uwsgi.queue = mmap(NULL, (uwsgi.queue_blocksize * uwsgi.queue_size)+16, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+			// fix header
+			uwsgi.queue_header = uwsgi.queue;
+			uwsgi.queue+=16;
+                	uwsgi.queue_header->pos = 0;
+                	uwsgi.queue_header->pull_pos = 0;
                 }
                 if (!uwsgi.queue) {
                         uwsgi_error("mmap()");
                         exit(1);
                 }
 
+
+
                 uwsgi.queue_lock = uwsgi_mmap_shared_rwlock();
                 uwsgi_rwlock_init(uwsgi.queue_lock);
 
@@ -78,33 +86,20 @@ char *uwsgi_queue_get(uint64_t index, uint64_t *size) {
 	
 }
 
-void uwsgi_queue_fix() {
-
-        uint64_t i;
-	char *value;
-	uint64_t size;
-
-        for(i=0;i< uwsgi.queue_size;i++) {
-                // valid record ?
-		value = uwsgi_queue_get(i, &size);
-		if (value && size) {
-			uwsgi.shared->queue_pos++;
-		}
-		else {
-			return;
-		}
-        }
-}
-
 
 char *uwsgi_queue_pop(uint64_t *size) {
 
         struct uwsgi_queue_item *uqi;
         char *ptr = (char *) uwsgi.queue;
 
-	if (uwsgi.shared->queue_pos > 0) uwsgi.shared->queue_pos--;
+	if (uwsgi.queue_header->pos == 0) {
+		uwsgi.queue_header->pos = uwsgi.queue_size-1;
+	}
+	else {
+		uwsgi.queue_header->pos--;
+	}
 
-        ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pos);
+        ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pos);
         uqi = (struct uwsgi_queue_item *) ptr;
 
         if (!uqi->size) return NULL;
@@ -122,16 +117,16 @@ char *uwsgi_queue_pull(uint64_t *size) {
 	struct uwsgi_queue_item *uqi;
 	char *ptr = (char *) uwsgi.queue;	
 
-	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pull_pos);
+	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pull_pos);
 	uqi = (struct uwsgi_queue_item *) ptr;
 
 	if (!uqi->size) return NULL;
 
 	*size = uqi->size;
 
-	uwsgi.shared->queue_pull_pos++;
+	uwsgi.queue_header->pull_pos++;
 
-	if (uwsgi.shared->queue_pull_pos >= uwsgi.queue_size) uwsgi.shared->queue_pull_pos = 0;
+	if (uwsgi.queue_header->pull_pos >= uwsgi.queue_size) uwsgi.queue_header->pull_pos = 0;
 
 	// remove item
 	uqi->size = 0;
@@ -150,7 +145,7 @@ int uwsgi_queue_push(char *message, uint64_t size) {
 
 	if (!size) return 0;
 
-	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pos);
+	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pos);
 	uqi = (struct uwsgi_queue_item *) ptr;
 
 	ptr += sizeof(struct uwsgi_queue_item);
@@ -159,9 +154,34 @@ int uwsgi_queue_push(char *message, uint64_t size) {
 	uqi->ts = time(NULL);
 	memcpy(ptr, message, size);
 
-	uwsgi.shared->queue_pos++;
+	uwsgi.queue_header->pos++;
 	
-	if (uwsgi.shared->queue_pos >= uwsgi.queue_size) uwsgi.shared->queue_pos = 0;
+	if (uwsgi.queue_header->pos >= uwsgi.queue_size) uwsgi.queue_header->pos = 0;
 
 	return 1;
 }
+
+int uwsgi_queue_set(uint64_t pos, char *message, uint64_t size) {
+
+        struct uwsgi_queue_item *uqi;
+        char *ptr = (char *) uwsgi.queue;
+
+        if (size > uwsgi.queue_blocksize + sizeof(struct uwsgi_queue_item))
+                return 0;
+
+        if (!size) return 0;
+
+	if (pos >= uwsgi.queue_size) return 0;
+
+        ptr = ptr + (uwsgi.queue_blocksize*pos);
+        uqi = (struct uwsgi_queue_item *) ptr;
+
+        ptr += sizeof(struct uwsgi_queue_item);
+
+        uqi->size = size;
+        uqi->ts = time(NULL);
+        memcpy(ptr, message, size);
+
+        return 1;
+}
+

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,23 @@ 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'):
+        profile = "%s.ini" % profile
+    if not '/' in profile:
+        profile = "buildconf/%s" % profile
+
+    return profile
 
 def patch_bin_path(cmd, conf):
 
@@ -26,30 +41,44 @@ def patch_bin_path(cmd, conf):
 class uWSGIBuilder(build_ext):
 
     def run(self):
-        conf = uc.uConf('buildconf/default.ini')
-        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('buildconf/default.ini')
-        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',
@@ -57,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);

skel.c

@@ -0,0 +1,10 @@
+/* this is a skeleton to use libuwsgi in external projects */
+
+extern char **environ;
+
+int uwsgi_init(int, char **, char **);
+
+int main(int argc, char **argv, char **environ) {
+
+	uwsgi_init(argc, argv, environ);
+}

snmp.c

@@ -350,123 +350,6 @@ static int get_snmp_integer(uint8_t * ptr, uint64_t * val) {
 			return size + oid_sz;
 
 		}
-
-		/*
-		   PyObject *py_snmp_counter32(PyObject * self, PyObject * args) {
-
-		   uint8_t oid_num;
-		   uint32_t oid_val = 0;
-
-		   if (!PyArg_ParseTuple(args, "bI:snmp_set_counter32", &oid_num, &oid_val)) {
-		   return NULL;
-		   }
-
-		   if (oid_num > 100 || oid_num < 1)
-		   goto clear;
-
-		   uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER32;
-		   uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-		   Py_INCREF(Py_True);
-		   return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_counter64(PyObject * self, PyObject * args) {
-
-uint8_t oid_num;
-uint64_t oid_val = 0;
-
-if (!PyArg_ParseTuple(args, "bK:snmp_set_counter64", &oid_num, &oid_val)) {
-return NULL;
-}
-
-if (oid_num > 100 || oid_num < 1)
-goto clear;
-
-uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER64;
-uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-Py_INCREF(Py_True);
-return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_gauge(PyObject * self, PyObject * args) {
-
-uint8_t oid_num;
-uint32_t oid_val = 0;
-
-if (!PyArg_ParseTuple(args, "bI:snmp_set_gauge", &oid_num, &oid_val)) {
-return NULL;
-}
-
-if (oid_num > 100 || oid_num < 1)
-goto clear;
-
-uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_GAUGE;
-uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-Py_INCREF(Py_True);
-return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_community(PyObject * self, PyObject * args) {
-
-	char *snmp_community;
-
-	if (!PyArg_ParseTuple(args, "s:snmp_set_community", &snmp_community)) {
-		return NULL;
-	}
-
-	if (strlen(snmp_community) > 72) {
-		uwsgi_log( "*** warning the supplied SNMP community string will be truncated to 72 chars ***\n");
-		memcpy(uwsgi.shared->snmp_community, snmp_community, 72);
-	}
-	else {
-		memcpy(uwsgi.shared->snmp_community, snmp_community, strlen(snmp_community) + 1);
-	}
-
-	Py_INCREF(Py_True);
-	return Py_True;
-
-}
-
-static PyMethodDef uwsgi_snmp_methods[] = {
-	{"snmp_set_counter32", py_snmp_counter32, METH_VARARGS, ""},
-	{"snmp_set_counter64", py_snmp_counter64, METH_VARARGS, ""},
-	{"snmp_set_gauge", py_snmp_gauge, METH_VARARGS, ""},
-	{"snmp_set_community", py_snmp_community, METH_VARARGS, ""},
-	{NULL, NULL},
-};
-
-void snmp_init() {
-
-	PyMethodDef *uwsgi_function;
-
-	for (uwsgi_function = uwsgi_snmp_methods; uwsgi_function->ml_name != NULL; uwsgi_function++) {
-		PyObject *func = PyCFunction_New(uwsgi_function, NULL);
-		PyDict_SetItemString(uwsgi.embedded_dict, uwsgi_function->ml_name, func);
-		Py_DECREF(func);
-	}
-
-	uwsgi_log( "SNMP python functions initialized.\n");
-}
-*/
-
 #else
 #warning "*** SNMP support is disabled ***"
 #endif

socket.c

@@ -474,7 +474,13 @@ socklen_t socket_to_in_addr(char *socket_name, char *port, struct sockaddr_in *s
                 sin_addr->sin_addr.s_addr = INADDR_ANY;
         }
         else {
-                sin_addr->sin_addr.s_addr = inet_addr(socket_name);
+		char *resolved = uwsgi_resolve_ip(socket_name);
+		if (resolved) {
+                	sin_addr->sin_addr.s_addr = inet_addr(resolved);
+		}
+		else {
+                	sin_addr->sin_addr.s_addr = inet_addr(socket_name);
+		}
         }
 
 	return sizeof(struct sockaddr_in);
@@ -749,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
@@ -951,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,18 +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]);
-		if (uwsgi.shared->spooler_signal_pipe[1] != -1) close (uwsgi.shared->spooler_signal_pipe[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);
@@ -36,23 +25,21 @@ pid_t spooler_start() {
 		// USR1 will be used to wake up the spooler
 		signal(SIGUSR1, spooler_wakeup);
 		uwsgi.mywid = -1;
-		uwsgi.mypid = pid;
+		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) {
                         	uwsgi.p[i]->post_fork();
                 	}
         	}
+
 		uwsgi.signal_socket = uwsgi.shared->spooler_signal_pipe[1];
+
 		for (i = 0; i < 0xFF; i++) {
                 	if (uwsgi.p[i]->spooler_init) {
                         	uwsgi.p[i]->spooler_init();
@@ -64,12 +51,10 @@ pid_t spooler_start() {
                         	uwsgi.gp[i]->spooler_init();
                 	}
         	}
+
 		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);
 	}
 
@@ -251,6 +236,8 @@ void spooler() {
 		if (uwsgi.spooler_ordered) {
 #ifdef __linux__
 			spooler_scandir(uwsgi.spool_dir);
+#else
+			spooler_readdir(uwsgi.spool_dir);
 #endif
 		}
 		else {
@@ -362,7 +349,12 @@ void spooler_manage_task(char *dir, char *task) {
 		if (!access(task, R_OK | W_OK)) {
 			uwsgi_log("managing spool request %s ...\n", task);
 
+#ifdef __sun__
+			// lockf needs write permission
+			spool_fd = open(task, O_RDWR);
+#else
 			spool_fd = open(task, O_RDONLY);
+#endif
 			if (spool_fd < 0) {
 				uwsgi_error_open(task);
 				return;
@@ -411,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);	
 					}
@@ -428,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;
+        }
+
+}
+
+

tests/queue.py

@@ -0,0 +1,48 @@
+# uwsgi --queue 10 --queue-store test.queue --master --module tests.queue --socket :3031
+
+import uwsgi
+import os
+from flask import Flask,render_template,request,redirect,flash
+
+app = Flask(__name__)
+app.debug = True
+app.secret_key = os.urandom(24)
+
+@app.route('/')
+def index():
+
+    return render_template('queue.html', uwsgi=uwsgi)
+
+@app.route('/push', methods=['POST'])
+def push_item():
+    if uwsgi.queue_push(request.form['body']):
+        flash('item enqueued')
+        return redirect('/')
+    else:
+        flash('unable to enqueue item')
+        return render_template('queue.html', uwsgi=uwsgi)
+
+@app.route('/get', methods=['POST'])
+def get_item():
+    flash( "slot %s value = %s" % (request.form['slot'], uwsgi.queue_get( int(request.form['slot']) )))
+    return redirect('/')
+
+@app.route('/pop', methods=['POST'])
+def pop_item():
+    flash( "popped value = %s" %  uwsgi.queue_pop() )
+    return redirect('/')
+
+@app.route('/pull', methods=['POST'])
+def pull_item():
+    flash( "pulled value = %s" %  uwsgi.queue_pull() )
+    return redirect('/')
+
+
+@app.route('/set', methods=['POST'])
+def set_item():
+    if uwsgi.queue_set(int(request.form['pos']), request.form['body']):
+        flash('item set')
+        return redirect('/')
+    else:
+        flash('unable to set item')
+        return render_template('queue.html', uwsgi=uwsgi)

tests/refcount.py

@@ -0,0 +1,6 @@
+import sys
+
+def application(e, sr):
+    sr('200 OK', [('Content-Type','text/html')])
+    print sys.gettotalrefcount()
+    yield '%s' % sys.gettotalrefcount()

tests/sharedarea.py

@@ -0,0 +1,16 @@
+import uwsgi
+
+uwsgi.sharedarea_writelong(173, 30)
+
+def application(e, sr):
+
+    sr('200 Ok', [('Content-Type','text/html')])
+
+    uwsgi.sharedarea_write(17, e['REQUEST_URI'])
+
+    uwsgi.sharedarea_inclong(173)
+    uwsgi.sharedarea_inclong(173, 17)
+
+    yield uwsgi.sharedarea_read(17, len(e['REQUEST_URI']))
+    yield "<br/>"
+    yield str(uwsgi.sharedarea_readlong(173))

tests/templates/queue.html

@@ -0,0 +1,50 @@
+<head>
+<style>
+.flash {
+color: red;
+}
+</style>
+</head>
+<body>
+{% with messages = get_flashed_messages() %}
+        {% if messages %}
+                <div class="flash">
+                        <ul>
+                        {% for message in messages %}
+                                <li>{{ message }}</li>
+                        {% endfor %}
+                        </ul>
+                </div>
+        {% endif %}
+{% endwith %}
+<h1>next available slot: {{uwsgi.queue_slot()}}</h1>
+<h1>next available pull slot: {{uwsgi.queue_pull_slot()}}</h1>
+{% for item in range(0, uwsgi.queue_size) %}
+
+slot {{item}} = {{uwsgi.queue_get(item)}}<br/>
+
+{% endfor %}
+
+<br/>
+
+<form method="POST" action="/push">
+<input type="text" name="body"><input type="submit" value="push value" /><br/>
+</form>
+
+<form method="POST" action="/get">
+<input type="text" name="slot" size="9"><input type="submit" value="get value" /><br/>
+</form>
+
+<form method="POST" action="/pop">
+<input type="submit" value="pop value" /><br/>
+</form>
+
+<form method="POST" action="/pull">
+<input type="submit" value="pull value" /><br/>
+</form>
+
+<form method="POST" action="/set">
+<input type="text" name="pos" size="5" /> <input type="text" name="body"><input type="submit" value="set value" /><br/>
+</form>
+
+</body>

tests/ugevent.py

@@ -0,0 +1,71 @@
+import gevent
+import gevent.socket
+import sys
+import uwsgi
+from uwsgidecorators import *
+
+if 'gettotalrefcount' in sys.__dict__:
+    REFCNT = True
+else:
+    REFCNT = False
+
+@signal(17)
+def hello(signum):
+    print "hello i am signal %d, i am here because the background job is finished" % signum
+    if REFCNT:
+        print sys.gettotalrefcount()
+
+@timer(10)
+def ten_seconds(signum):
+    print "10 seconds elapsed, signal %d raised" % signum
+    if REFCNT:
+        print sys.gettotalrefcount()
+
+@filemon('/tmp')
+def tmp_modified(signum):
+    print "/tmp has been touched, i am the greenlet %s running on worker %d" % (gevent.getcurrent(), uwsgi.worker_id())
+    if REFCNT:
+        print sys.gettotalrefcount()
+
+def bg_task():
+    for i in range(1,10):
+        print "background task", i
+        gevent.sleep(1)
+
+    # task ended raise a signal !!!
+    uwsgi.signal(17)
+
+def long_task():
+    for i in range(1,10):
+        print i
+        gevent.sleep()
+
+def application(e, sr):
+
+    sr('200 OK', [('Content-Type','text/html')])
+
+    t = gevent.spawn(long_task)
+
+    t.join()
+
+    yield "sleeping for 3 seconds...<br/>"
+
+    gevent.sleep(3)
+
+    yield "done<br>"
+
+    yield "getting some ips...<br/>"
+
+    urls = ['www.google.com', 'www.example.com', 'www.python.org', 'projects.unbit.it']
+    jobs = [gevent.spawn(gevent.socket.gethostbyname, url) for url in urls]
+    gevent.joinall(jobs, timeout=2)
+
+    for j in jobs:
+        yield "ip = %s<br/>" % j.value
+
+    if REFCNT:
+        print sys.gettotalrefcount()
+        yield "%d" % sys.gettotalrefcount()
+
+    # this task will goes on after request end
+    gevent.spawn(bg_task)

tests/werkzeug.py

@@ -0,0 +1,5 @@
+import uwsgi
+
+print(uwsgi.opt)
+print(uwsgi.magic_table)
+from werkzeug.testapp import test_app as application

uploadtest.py

@@ -1,5 +1,19 @@
+import uuid
+import uwsgi
+import os
+
+
 def application(env, start_response):
 
+    if env['PATH_INFO'].startswith('/progress/'):
+        start_response('200 Ok', [('Content-type', 'application/json')])
+        filename = 'foobar/' + env['PATH_INFO'][10:]
+        print filename
+       	if os.path.exists(filename): 
+            return uwsgi.sendfile(filename)
+        else:
+            return "{ 'state': 'done' }"
+	
 
     if env['REQUEST_METHOD'] == 'POST':
     	start_response('200 Ok', [('Content-type', 'text/plain')])
@@ -14,12 +28,44 @@ def application(env, start_response):
 	return body
     else:
     	start_response('200 Ok', [('Content-type', 'text/html')])
+        x_progress_id = str(uuid.uuid4())
         return """
-<form method="POST" enctype="multipart/form-data">
+<html>
+<head>
+<script src="/static/jquery-1.5.1.min.js" /></script>
+<script language="Javascript">
+var interval;
+function redrawProgressBar() {
+	interval = setInterval(getData, 1000);
+}
+
+function getData() {
+	var jsr = $.getJSON("/progress/%s.js",
+        	function(data) {
+			if (data) {
+				if (data.state == 'uploading') {
+					$('#progress').html(data.received + '/' + data.size);
+					return;
+				}
+			}
+			alert("fine");
+			clearInterval(interval);
+                }
+	);
+	jsr.error(function() { clearInterval(interval); });
+
+}
+</script>
+</head>
+<body>
+upload progress: <div id="progress"> 0%%</div>
+<form method="POST" enctype="multipart/form-data" action="?X-Progress-ID=%s" onsubmit="redrawProgressBar(); return true;">
 	<textarea name="pluto">
 	</textarea>
     <input type="file" name="pippo" />
     <input type="submit" value="invia" />
 </form>
-        """
+</body>
+</html>
+        """ % (x_progress_id, x_progress_id)
 

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;
@@ -323,6 +349,11 @@ struct uwsgi_daemon {
 	//int pipe[2];
 };
 
+struct uwsgi_queue_header {
+	uint64_t pos;
+	uint64_t pull_pos;
+};
+
 struct uwsgi_queue_item {
 	uint64_t size;
 	time_t ts;
@@ -480,6 +511,32 @@ struct uwsgi_opt {
 #define LONG_ARGS_HTTP_SOCKET		17132
 #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
@@ -518,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
@@ -576,6 +635,8 @@ struct uwsgi_socket {
 	int disabled;
 
 	struct uwsgi_socket *next;
+	int shared;
+	int from_shared;
 };
 
 struct uwsgi_server;
@@ -599,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 *);
@@ -617,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 {
 
@@ -633,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;
 
@@ -667,6 +743,7 @@ struct uwsgi_app {
         void *uwsgi_version;
         void *uwsgi_node;
 
+	uint64_t avg_response_time;
 };
 
 
@@ -757,6 +834,7 @@ struct wsgi_request {
 
 	char *path_info;
 	uint16_t path_info_len;
+	int path_info_pos;
 
 	char *script;
 	uint16_t script_len;
@@ -895,89 +973,159 @@ 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;
 	int emperor_fd_config;
 	int early_emperor;
+        int emperor_throttle;
 	char *emperor_dir;
 	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;
 
@@ -985,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;
 
@@ -1000,23 +1157,29 @@ 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;
 
 	struct iovec **async_hvec;
 	char **async_buf;
 	char **async_post_buf;
-	char **mem_post_buf;
 
+	// async commodity
 	struct wsgi_request **async_waiting_fd_table;
 	struct wsgi_request **async_proto_fd_table;
 	struct uwsgi_async_request *async_runqueue;
@@ -1033,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;
@@ -1061,7 +1232,9 @@ struct uwsgi_server {
 
 #ifdef UWSGI_SPOOLER
 	char *spool_dir;
+	char *spooler_chdir;
 	int spooler_ordered;
+	uint64_t spooler_respawned;
 #endif
 
 #ifdef UWSGI_SNMP
@@ -1079,6 +1252,7 @@ struct uwsgi_server {
 
 	int buffer_size;
 
+	// post buffering
 	int post_buffering;
 	int post_buffering_harakiri;
 	int post_buffering_bufsize;
@@ -1086,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;
@@ -1097,6 +1272,8 @@ struct uwsgi_server {
 
 	int harakiri_verbose;
 
+	char *magic_table[256];
+
 	int numproc;
 	int async;
 	int async_running;
@@ -1108,11 +1285,12 @@ struct uwsgi_server {
 	int max_vars;
 	int vec_size;
 
+	// shared area
 	char *sharedarea;
-	void *sharedareamutex;
-	int sharedareasize;
+	uint64_t sharedareasize;
 
 #ifdef UWSGI_THREADING
+	// avoid thundering herd in threaded modes
 	pthread_mutex_t six_feet_under_lock;
 #endif
 
@@ -1120,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;
@@ -1165,7 +1350,7 @@ struct uwsgi_server {
 #endif
 
 #ifdef UWSGI_INI
-	char *ini;
+	struct uwsgi_string_list *ini;
 #endif
 
 #ifdef UWSGI_SQLITE3
@@ -1196,6 +1381,7 @@ struct uwsgi_server {
 
 	char *cwd;
 
+	// conditional logging
 	int log_slow_requests;
 	int log_zero_headers;
 	int log_empty_body;
@@ -1297,24 +1483,32 @@ 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;
+	struct uwsgi_queue_header *queue_header;
 	char *queue_store;
 	size_t queue_filesize;
 	int queue_store_sync;
 
 	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;
 	void *rb_timer_table_lock;
 	void *cron_table_lock;
 	void *rpc_table_lock;
+        void *sa_lock;
 #ifdef UWSGI_SPOOLER
 	void *spooler_lock;
 #endif
@@ -1324,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;
 
 };
 
@@ -1424,6 +1618,7 @@ struct uwsgi_shared {
 #ifdef UWSGI_SPOOLER
 	pid_t spooler_pid;
 	int spooler_frequency;
+	time_t spooler_harakiri;
 #endif
 
 #ifdef UWSGI_SNMP
@@ -1440,13 +1635,14 @@ struct uwsgi_shared {
 	uint64_t cache_first_available_item;
 	uint64_t cache_unused_stack_ptr;
 
-	uint64_t queue_pos;
-	uint64_t queue_pull_pos;
 
 	int worker_signal_pipe[2];
 #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];
@@ -1517,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;
 
@@ -1529,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);
@@ -1558,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);
@@ -1581,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__
@@ -1699,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);
@@ -1720,7 +1972,7 @@ struct wsgi_request *threaded_current_wsgi_req(void);
 void build_options(void);
 
 int uwsgi_read_whole_body(struct wsgi_request *, char *, size_t);
-int uwsgi_read_whole_body_in_mem(struct wsgi_request *, char *, size_t);
+int uwsgi_read_whole_body_in_mem(struct wsgi_request *, char *);
 
 ssize_t uwsgi_sendfile(struct wsgi_request *);
 
@@ -1867,6 +2119,8 @@ void uwsgi_init_cache(void);
 char *uwsgi_queue_get(uint64_t, uint64_t *);
 char *uwsgi_queue_pull(uint64_t *);
 int uwsgi_queue_push(char *, uint64_t);
+char *uwsgi_queue_pop(uint64_t *);
+int uwsgi_queue_set(uint64_t, char *, uint64_t);
 
 // maintain alignment here !!!
 struct uwsgi_dict_item {
@@ -1899,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;
@@ -1941,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"
 
@@ -1993,8 +2219,6 @@ inline int event_queue_write(void);
 
 void uwsgi_help(void);
 
-void uwsgi_queue_fix(void);
-
 int uwsgi_str2_num(char *);
 int uwsgi_str3_num(char *);
 int uwsgi_str4_num(char *);
@@ -2106,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 *);
 
@@ -2148,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
@@ -25,13 +25,15 @@ GCC = os.environ.get('CC', sysconfig.get_config_var('CC'))
 if not GCC:
     GCC = 'gcc'
 
+CPP = os.environ.get('CPP', 'cpp')
+
 binary_list = []
 	
 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:
@@ -57,10 +59,22 @@ def spcall2(cmd):
     else:
         return None
 
+def spcall3(cmd):
+    p = subprocess.Popen(cmd, shell=True, stdin=open('/dev/null'), stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+
+    if p.wait() == 0:
+        if sys.version_info[0] > 2:
+            return p.stderr.read().rstrip().decode()
+        return p.stderr.read().rstrip()
+    else:
+        return None
+
 
 def add_o(x):
     if x == 'uwsgi':
         x = 'main'
+    elif x.endswith('.a'):
+        return x
     x = x + '.o'
     return x
 
@@ -100,7 +114,7 @@ def build_uwsgi(uc):
         epc = "-DUWSGI_DECLARE_EMBEDDED_PLUGINS=\""
         eplc = "-DUWSGI_LOAD_EMBEDDED_PLUGINS=\""
         for p in ep:
-            p = p.rstrip().lstrip()
+            p = p.strip()
             if p == 'ugreen':
                 if uwsgi_os == 'OpenBSD' or uwsgi_cpu[0:3] == 'arm' or uwsgi_os == 'Haiku':
                     continue
@@ -117,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(',')
@@ -125,7 +140,7 @@ def build_uwsgi(uc):
         if len(ep) > 0:
             print("*** uWSGI compiling embedded plugins ***")
             for p in ep:
-                p = p.rstrip().lstrip()
+                p = p.strip()
 
                 if p == 'ugreen':
                     if uwsgi_os == 'OpenBSD' or uwsgi_cpu[0:3] == 'arm' or uwsgi_os == 'Haiku':
@@ -140,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
@@ -160,7 +183,7 @@ def build_uwsgi(uc):
             print("*** uWSGI building plugins ***")
 
             for p in plugins:
-                p = p.rstrip().lstrip()
+                p = p.strip()
                 print("*** building plugin: %s ***" % p)
                 build_plugin("plugins/%s" % p, uc, cflags, ldflags, libs)
 
@@ -182,7 +205,10 @@ def build_uwsgi(uc):
 
     if bin_name.find("/") < 0:
         bin_name = './' + bin_name
-    print("*** uWSGI is ready, launch it with %s ***" % bin_name)
+    if uc.get('as_shared_library'):
+        print("*** uWSGI shared library (%s) is ready, move it to a library directory ***" % bin_name)
+    else:
+        print("*** uWSGI is ready, launch it with %s ***" % bin_name)
 
 
 class uConf(object):
@@ -190,25 +216,64 @@ class uConf(object):
     def __init__(self, filename):
         self.config = ConfigParser.ConfigParser()
         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')
         self.gcc_list.append('proto/uwsgi')
         self.gcc_list.append('proto/http')
         self.gcc_list.append('proto/fastcgi')
+        self.include_path = []
         if uwsgi_os == 'Linux':
             self.gcc_list.append('lib/linux_ns')
             self.gcc_list.append('lib/netlink')
         self.cflags = ['-O2', '-Wall', '-Werror', '-D_LARGEFILE_SOURCE', '-D_FILE_OFFSET_BITS=64'] + os.environ.get("CFLAGS", "").split()
+
         try:
             gcc_version = str(spcall("%s -dumpversion" % GCC))
         except:
             print("*** you need a c compiler to build uWSGI ***")
             sys.exit(1)
-        gcc_major = int(gcc_version.split('.')[0])
-        gcc_minor = int(gcc_version.split('.')[1])
+
+        try:
+            add_it = False
+            cpp_include_list = str(spcall3("%s -v" % CPP)).split("\n")
+            for line in cpp_include_list:
+                if line.startswith('#include <...> search starts here:'):
+                    add_it = True
+                elif line.startswith('End of search list.'):
+                    add_it = False
+                elif add_it:
+                    self.include_path.append(line.strip().split()[0])
+            
+            if not self.include_path:
+                raise 
+        except:
+            self.include_path = ['/usr/include', '/usr/local/include']
+            
+            
+        print("detected include path: %s" % self.include_path)
+
+        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
@@ -261,6 +326,12 @@ class uConf(object):
                 print("%s needs %s support." % (what, d))
                 sys.exit(1)
 
+    def has_include(self, what):
+        for include in self.include_path:
+            if os.path.exists("%s/%s" %(include, what)):
+                return True
+        return False
+
     def get_gcll(self):
 
         global uwsgi_version
@@ -268,7 +339,7 @@ class uConf(object):
         self.cflags.append('-DUWSGI_BUILD_DATE="\\"%s\\""' % time.strftime("%d %B %Y %H:%M:%S"))
         kvm_list = ['FreeBSD', 'OpenBSD', 'NetBSD', 'DragonFly']
 
-        if os.path.exists('/usr/include/ifaddrs.h') or os.path.exists('/usr/local/include/ifaddrs.h'):
+        if self.has_include('ifaddrs.h'):
             self.cflags.append('-DUWSGI_HAS_IFADDRS')
 
         if uwsgi_os == 'SunOS':
@@ -342,7 +413,10 @@ class uConf(object):
                 k_all = uwsgi_os_k.split('.')
                 k_base = k_all[0]
                 k_major = k_all[1]
-                k_minor = k_all[2]
+                if len(k_all) > 2:
+                    k_minor = k_all[2]
+                else:
+                    k_minor = 0
                 if int(k_base) > 2:
                     timer_mode = 'timerfd'
                 elif int(k_minor) >= 25:
@@ -361,7 +435,7 @@ class uConf(object):
 
         if timer_mode == 'timerfd':
             self.cflags.append('-DUWSGI_EVENT_TIMER_USE_TIMERFD')
-            if not os.path.exists('/usr/include/sys/timerfd.h') and not os.path.exists('/usr/local/include/sys/timerfd.h'):
+            if not self.has_include('sys/timerfd.h'):
                 self.cflags.append('-DUWSGI_EVENT_TIMER_USE_TIMERFD_NOINC')
         elif timer_mode == 'kqueue':
             self.cflags.append('-DUWSGI_EVENT_TIMER_USE_KQUEUE')
@@ -404,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')
@@ -412,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:
@@ -434,10 +511,14 @@ 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
 
-        if os.path.exists('/usr/include/uuid/uuid.h') or os.path.exists('/usr/local/include/uuid/uuid.h'):
+        if self.has_include('uuid/uuid.h'):
             has_uuid = True
             self.cflags.append("-DUWSGI_UUID")
             if os.path.exists('/usr/lib/libuuid.so') or os.path.exists('/usr/local/lib/libuuid.so') or os.path.exists('/usr/lib64/libuuid.so') or os.path.exists('/usr/local/lib64/libuuid.so'):
@@ -542,7 +623,7 @@ class uConf(object):
                 self.cflags.append("-DUWSGI_LIBYAML")
                 self.libs.append('-lyaml')
             if self.get('yaml_implementation') == 'auto':
-                if os.path.exists('/usr/include/yaml.h') or os.path.exists('/usr/local/include/yaml.h'):
+                if self.has_include('yaml.h'):
                     self.cflags.append("-DUWSGI_LIBYAML")
                     self.libs.append('-lyaml')
 
@@ -555,7 +636,7 @@ class uConf(object):
                     self.gcc_list.append('json')
                     self.libs.append(spcall("pkg-config --libs jansson"))
                     has_json = True
-                elif os.path.exists('/usr/include/jansson.h') or os.path.exists('/usr/local/include/jansson.h'):
+                elif self.has_include('jansson.h'):
                     self.cflags.append("-DUWSGI_JSON")
                     self.gcc_list.append('json')
                     self.libs.append('-ljansson')
@@ -568,7 +649,7 @@ class uConf(object):
 
         if self.get('ldap'):
             if self.get('ldap') == 'auto':
-                if os.path.exists('/usr/include/ldap.h'):
+                if self.has_include('ldap.h'):
                     self.cflags.append("-DUWSGI_LDAP")
                     self.gcc_list.append('ldap')
                     self.libs.append('-lldap')
@@ -579,7 +660,7 @@ class uConf(object):
 
         if has_uuid and self.get('zeromq'):
             if self.get('zeromq') == 'auto':
-                if os.path.exists('/usr/include/zmq.h') or os.path.exists('/usr/local/include/zmq.h'):
+                if self.has_include('zmq.h'):
                     self.cflags.append("-DUWSGI_ZEROMQ")
                     self.gcc_list.append('proto/zeromq')
                     self.libs.append('-lzmq')
@@ -627,7 +708,7 @@ class uConf(object):
 
         if self.get('sqlite3'):
             if self.get('sqlite3') == 'auto':
-                if os.path.exists('/usr/include/sqlite3.h') or os.path.exists('/usr/local/include/sqlite3.h'):
+                if self.has_include('sqlite3.h'):
                     self.cflags.append("-DUWSGI_SQLITE3")
                     self.libs.append('-lsqlite3')
                     self.gcc_list.append('sqlite3')
@@ -675,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'
@@ -685,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)
@@ -695,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)
 
@@ -719,13 +816,13 @@ if __name__ == "__main__":
     if cmd == '--libs':
         print(' '.join(libs))
     elif cmd == '--build':
-        bconf = 'default.ini'
+        bconf = os.environ.get('UWSGI_PROFILE','default.ini')
         try:
             bconf = sys.argv[2]
-            if not bconf.endswith('.ini'):
-                bconf += '.ini'
         except:
             pass
+        if not bconf.endswith('.ini'):
+            bconf += '.ini'
         if not '/' in bconf:
             bconf = 'buildconf/%s' % bconf
         build_uwsgi(uConf(bconf))

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,11 +257,23 @@ 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
 
     def __call__(self, *args, **kwargs):
+        # ensure the spooler will not call it
+        if uwsgi.i_am_the_spooler():
+            return
         uwsgi.lock()
         try:
             return self.f(*args, **kwargs)

welcome.ini

@@ -0,0 +1,11 @@
+[uwsgi]
+socket = :$(PORT)
+socket = /tmp/uwsgi_welcome.socket
+vacuum = true
+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)
 
 
 

welcome3.py

@@ -0,0 +1,57 @@
+import uwsgi
+import os
+
+def xsendfile(e, sr):
+    sr('200 OK', [('Content-Type', 'image/png'), ('X-Sendfile', os.path.abspath('logo_uWSGI.png'))])
+    return b''
+
+def serve_logo(e, sr):
+    sr('200 OK', [('Content-Type', 'image/png')])
+    return uwsgi.sendfile('logo_uWSGI.png')
+
+def serve_options(e, sr):
+    sr('200 OK', [('Content-Type', 'text/html')])
+    for opt in range(0,256):
+        body = "{opt} = {optvalue}<br/>".format(opt=opt, optvalue=uwsgi.get_option(opt))
+        yield bytes(body.encode('ascii'))
+
+def serve_config(e, sr):
+    sr('200 OK', [('Content-Type', 'text/html')])
+    for opt in uwsgi.opt.keys():
+        body = "{opt} = {optvalue}<br/>".format(opt=opt, optvalue=uwsgi.opt[opt].decode('ascii'))
+        yield bytes(body.encode('ascii'))
+
+routes = {}
+routes['/xsendfile'] = xsendfile
+routes['/logo'] = serve_logo
+routes['/config'] = serve_config
+routes['/options'] = serve_options
+
+def application(env, start_response):
+
+    if env['PATH_INFO'] in routes:
+        return routes[env['PATH_INFO']](env, start_response)
+
+    start_response('200 OK', [('Content-Type', 'text/html')])
+
+    body = """
+<img src="/logo"/> version {version}<br/>
+<hr size="1"/>
+
+Configuration<br/>
+<iframe src="/config"></iframe><br/>
+
+<br/>
+
+Dynamic options<br/>
+<iframe src="/options"></iframe><br/>
+
+    """.format(version=uwsgi.version.decode('ascii'))
+
+    return bytes(body.encode('ascii'))
+
+
+
+
+
+