uWSGI 0.9.8.2

.hgignore

@@ -0,0 +1,4 @@
+syntax: glob
+
+*.o
+*.pyc

.hgtags

@@ -21,3 +21,8 @@ d9b9b540f7dce8cb05d2e61ca8b4d75f2ea25f62 0.9.7.1
 486e7760bcbc2191ddb9b4aee6c98dbd5fc4c754 0.9.7.1
 a5f13497b39269621f8f1e56e14d2cc141452e79 0.9.7.2
 d1e57707f6317f134fea7d12f6588d8690f74f3f 0.9.8-rc1
+e91bc724325e14c13b8f548c0b6a315c48a1c32a 0.9.8-rc2
+4fb424d52f226a0a087fea89709f5eb540e03f25 0.9.8-rc3
+0f1f3924ee5309a9990d9af1ffc68846e3dfb31b 0.9.8-rc4
+42efe1f329005618c8b44f901979ebcecd5216fb 0.9.8
+fd8477b6348faf16588106055ca59df1c488f76a 0.9.8.1

CONTRIBUTORS

@@ -0,0 +1,14 @@
+- this is a incomplete list of all the contributors of the project -
+
+Roberto De Ioris, Unbit, <roberto@unbit.it>
+Riccardo Magliocchetti, Unbit, <riccardo@unbit.it>
+Yann Malet, Lincoln Loop
+Simon Litchfield
+Masahiro Honma, <hiratara@cpan.org>
+Łukasz Wróblewski <admin@nri.pl>
+Giacomo Bagnoli, Asidev
+Guido Notari, Link I.T. S.p.a.
+Marco Beri, Link I.T. S.p.a.
+Leonid Borisenko
+Cal Leeming, Simplicity Media Ltd
+Luigi Scarso

ChangeLog

@@ -1,5 +1,113 @@
+*** july 2011 ***
+
+ * 0.9.8.2 [20110719]
+
+- fixed an ini and yaml parsing bug spotted by Raffaele Colace
+- spooler has been extremely improved
+- new option --chown-socket
+- added uwsgidecorators for elegant uwsgi api access from python
+- the rack plugin is now stable
+- support for embedding config and generic files in the server binary
+- high-performance cache-server
+- accept() is now locked on all threads in the same workers
+- preliminary implementation of hooks in emperor
+- support for C++ in server core
+- tcp port auto-bind
+- implemented workers, workerN and spooler signal target
+- prefork/multithread uwsgi.signal_wait() implementation
+- export uwsgi.node in WSGI vars
+- new option --import (python plugin)
+- support for unlimited number of Linux cgroups
+- broodlord mode
+
+*** june 2011 ***
+
+ * 0.9.8.1 [20110625]
+
+- the build system has been improved
+- various threading fixes
+- fix python GIL status after reload
+- new option --propagate-touch
+- fixed uwsgi.sendfile
+- fixed readline() support in wsgi.input
+- fixed dynamic touch reload
+- new option --logto2
+- export %c in config files
+- fixed libyaml support
+- support passing modifiers in subscription system
+- reset random seed in spooler
+- subscribe from a list in a text file
+- allow binding on port 0 (auto-assignment)
+- reset random seed on grunt
+- fix vhost mode for empty hostname
+- fixed python3+virtualenv support
+- tasks are now allowed to chdir() in spooler
+- better zeromq+clustering support
+- clustering has been refactored
+- fixed rpc
+- report correct worker id in cheap mode
+- fixed a fd-leak in attach-daemon
+- use setsid() in attach-daemon
+- zerg mode
+- added psgix.harakiri
+- allows magic vars in sqlite3 config db
+- added UWSGI_FASTROUTER_KEY var
+- slowdown async-queue-is-full messages
+- new option --cron
+- --vassals-start-hook and --vassals-stop-hook
+- the proxy plugin has been removed
+
+ * 0.9.8 [20110605]
+
+- support for --callable in virtualhosting mode
+- a NetBSD fix
+- abstract unix socket can be prefixed with \0 (nginx-style)
+- add /lib to the linker in sun-like systems
+- a mercy mode of 5 seconds is enabled by default on SIGINT/SIGQUIT
+
+ * 0.9.8-rc4 [20110602]
+
+- fixed REMOTE_ADDR when --protocol=http
+- official support for OpenIndiana
+- added a welcome.py test script
+- new api attribute uwsgi.version_info
+- improved the admin plugin
+- two new management flag for backlog queue monitoring
+- fixed uwsgi_log for bigger loglines
+- new option --early-emperor to allows out-of-jail emperors
+- emperor can now spawn other emperors (sub-emperors)
+- fixed idle mode in single-process
+- fixed solaris iovec
+
 *** may 2011 ***
 
+ * 0.9.8-rc3 [20110530]
+
+- snapshotting support
+- fixed python 3.x spooler
+- improvements for grunt processes
+- better abstract unix socket
+- --log-socket allows logging to generic DGRAM sockets
+- a bunch of solaris fixes
+- new option --no-fd-passing for fastrouter
+- --fastrouter-subscription-slot to set the number of slot in subscription server
+- unlimited shared sockets
+- fixed netlink compilation
+- auto-reconnect on emperor+amqp server disconnection
+- various emperor fixes
+- unlimited fastrouter sockets
+- better cgroup support
+- --add-header option allow adding of custom HTTP response headers
+- cheap and idle operational modes
+
+
+ * 0.9.8-rc2 [20110521]
+
+- new option --die-on-term
+- fixed touch reload
+- a couple of optimizations for wsgi.input
+- systemd integration
+
  * 0.9.8-rc1 [20110514]
 
 - massive code cleanup and refactoring

Makefile

@@ -1,2 +1,5 @@
 all:
 	python uwsgiconfig.py --build
+
+clean:
+	python uwsgiconfig.py --clean

async.c

@@ -202,10 +202,12 @@ void *async_loop(void *arg1) {
 	int is_a_new_connection;
 	int proto_parser_status;
 
+	time_t now, last_now = 0;
+
 	static struct uwsgi_async_request *current_request = NULL, *next_async_request = NULL;
 
 	void *events = event_queue_alloc(64);
-	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+	struct uwsgi_socket *uwsgi_sock;
 
 	uwsgi.async_runqueue = NULL;
 	uwsgi.async_runqueue_cnt = 0;
@@ -260,7 +262,11 @@ void *async_loop(void *arg1) {
 
 					uwsgi.wsgi_req = find_first_available_wsgi_req();
 					if (uwsgi.wsgi_req == NULL) {
-						uwsgi_log("async queue is full !!!\n");
+						now = time(NULL);
+						if (now > last_now) {
+							uwsgi_log("async queue is full !!!\n");
+							last_now = now;
+						}
 						break;;
 					}
 
@@ -318,7 +324,9 @@ void *async_loop(void *arg1) {
 					// parsing complete
 					if (!proto_parser_status) {
 						// remove fd from event poll and fd proto table	
+#ifndef UWSGI_EVENT_USE_PORT
 						event_queue_del_fd(uwsgi.async_queue, interesting_fd, event_queue_read());
+#endif
 						uwsgi.async_proto_fd_table[interesting_fd] = NULL;
 						// put request in the runqueue
 						runqueue_push(uwsgi.wsgi_req);

bootstrap.py

@@ -0,0 +1,4 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.SymbolsImporter())

build/README

@@ -0,0 +1 @@
+object file for embedded files will be put here

buildconf/default.ini

@@ -25,6 +25,7 @@ yaml_implementation = auto
 malloc_implementation = libc
 plugins =
 bin_name = uwsgi
+append_version =
 plugin_dir = .
 embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, ugreen
 
@@ -33,6 +34,10 @@ event = auto
 timer = auto
 filemonitor = auto
 
+embed_files =
+
+embed_config =
+
 [python]
 paste = true
 web3 = true

buildconf/embedded.ini

@@ -0,0 +1,4 @@
+[uwsgi]
+inherit = default
+
+embed_files = embedme.py,uwsgidecorators.py

buildconf/unbit.ini

@@ -2,6 +2,9 @@
 xml = true
 ini = true
 yaml = true
+json = true
+sqlite3 = true
+zeromq = false
 snmp = false
 sctp = false
 spooler = true
@@ -10,14 +13,23 @@ udp = true
 multicast = false
 threading = true
 sendfile = true
-nagios = false
 minterpreters = true
 async = true
+evdis = false
 ldap = true
+pcre = false
 debug = false
 unbit = true
 xml_implementation = libxml2
+yaml_implementation = auto
+malloc_implementation = libc
 plugins =
 bin_name = /opt/unbit/bin/uwsgi
+append_version = unbit
 plugin_dir = /opt/unbit/uwsgi_plugins
 embedded_plugins =
+
+locking = auto
+event = auto
+timer = auto
+filemonitor = auto

buildconf/unbitstaff.ini

@@ -1,5 +1,6 @@
 [uwsgi]
 inherit = unbit
+json = false
 embedded_plugins = python
 bin_name = ../bin/uwsgi
 plugin_dir = ../bin/uwsgi_plugins

cache.c

@@ -131,7 +131,7 @@ struct uwsgi_subscriber_name *uwsgi_get_subscriber(struct uwsgi_dict *udict, cha
 	return ret;
 }
 
-void uwsgi_add_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen, char *address, uint64_t address_len) {
+void uwsgi_add_subscriber(struct uwsgi_dict *udict, struct uwsgi_subscribe_req *usr) {
 
 	char *ptr;
 	uint64_t vallen = 0;
@@ -139,11 +139,11 @@ void uwsgi_add_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen,
 	int found = 0;
 	int i;
 	
-	ptr = uwsgi_dict_get(udict, key, keylen, &vallen);
+	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, address, address_len)) {
+			if (!uwsgi_strncmp(usub->names[i].name, usub->names[i].len, usr->address, usr->address_len)) {
 				found = 1;
 				break;
 			}
@@ -157,8 +157,10 @@ void uwsgi_add_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen,
 					break;
 				}
 			}
-			usub->names[found].len = address_len;
-			memcpy(usub->names[found].name, address, address_len);
+			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++;
 			}
@@ -168,8 +170,10 @@ void uwsgi_add_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen,
 	else {
 		nusub.nodes = 1;
 		nusub.current = 0;
-		memcpy(nusub.names[0].name, address, address_len);
-		uwsgi_dict_set(udict, key, keylen, (char *) &nusub, sizeof(struct uwsgi_subscriber));
+		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));
 	}
 
 }
@@ -578,3 +582,124 @@ end:
         return ret;
 
 }
+
+/* THIS PART IS HEAVILY OPTIMIZED: PERFORMANCE NOT ELEGANCE !!! */
+
+void *cache_thread_loop(void *fd_ptr) {
+
+	int *fd_tmp = (int *) fd_ptr;
+	int fd = *fd_tmp;
+	int i;
+	ssize_t len;
+	char uwsgi_packet[UMAX16+4];
+	struct uwsgi_header *uh = (struct uwsgi_header *) uwsgi_packet;
+	char *val;
+	uint64_t vallen;
+	char *key;
+	uint16_t keylen;
+	struct pollfd ctl_poll;
+	char *watermark;
+	struct sockaddr_un ctl_sun;
+	socklen_t ctl_sun_len;
+
+	ctl_poll.events = POLLIN;
+
+	for(;;) {
+		ctl_sun_len = sizeof(struct sockaddr_un);
+		pthread_mutex_lock(&uwsgi.cache_server_lock);
+
+		ctl_poll.fd = accept(fd, (struct sockaddr *) &ctl_sun, &ctl_sun_len);
+
+		pthread_mutex_unlock(&uwsgi.cache_server_lock);
+
+		if (ctl_poll.fd < 0) {
+			uwsgi_error("cache accept()");
+			continue;
+		}
+		i = 0;
+		while(i < 4) {
+			len = poll(&ctl_poll, 1, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+			if (len <= 0) {
+				uwsgi_error("cache poll()");
+				goto clear;
+			}
+			len = read(ctl_poll.fd, uwsgi_packet+i, 4-i);
+			if (len < 0) {
+				uwsgi_error("cache read()");
+				goto clear;
+			}
+			i+=len;
+		}
+
+		if (uh->pktsize == 0) goto clear;
+
+		while(i < 4+uh->pktsize) {
+			len = poll(&ctl_poll, 1, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+			if (len <= 0) {
+				uwsgi_error("cache poll()");
+				goto clear;
+			}
+			len = read(ctl_poll.fd, uwsgi_packet+i, (4+uh->pktsize)-i);
+			if (len < 0) {
+				uwsgi_error("cache read()");
+				goto clear;
+			}
+			i+=len;
+		}
+
+		watermark = uwsgi_packet+4+uh->pktsize;
+
+		// get first parameter
+		memcpy(&keylen, uwsgi_packet+4, 2);
+#ifdef __BIG_ENDIAN__
+        	keylen = uwsgi_swap16(keylen);
+#endif
+		if (uwsgi_packet+6+keylen > watermark) goto clear;
+		key = uwsgi_packet+6+keylen+2;
+		memcpy(&keylen, key-2, 2);
+#ifdef __BIG_ENDIAN__
+        	keylen = uwsgi_swap16(keylen);
+#endif
+
+		if (key+keylen > watermark) goto clear;
+
+		val = uwsgi_cache_get(key, keylen, &vallen);
+                if (val && vallen > 0) {
+                	if (write(ctl_poll.fd, val, vallen) < 0) {
+				uwsgi_error("cache write()");
+			}
+		}
+
+clear:
+		close(ctl_poll.fd);
+	}
+
+}
+
+int uwsgi_cache_server(char *socket, int threads) {
+
+	int *fd = uwsgi_malloc(sizeof(int));
+	
+	int i;
+	pthread_t thread_id;
+        char *tcp_port = strchr(socket, ':');
+        if (tcp_port) {
+                *fd = bind_to_tcp(socket, uwsgi.listen_queue, tcp_port);
+        }
+        else {
+                *fd = bind_to_unix(socket, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+        }
+
+        pthread_mutex_init(&uwsgi.cache_server_lock, NULL);
+
+	if (threads < 1) threads = 1;
+
+	uwsgi_log("*** cache-optimized server enabled on fd %d (%d threads) ***\n", *fd, threads);
+
+	for(i=0;i<threads;i++) {
+		pthread_create(&thread_id, NULL, cache_thread_loop, (void *) fd);
+	}
+
+        return *fd;
+}
+

decoratortest.py

@@ -0,0 +1,122 @@
+#!./uwsgi --import decoratortest -s :3035 -M --spooler myspool --enable-threads -p 8 --spooler-ordered
+import uwsgi
+
+from uwsgidecorators import *
+
+from uwsgicc import app as application
+
+import time
+
+
+# register rpc function helloworld
+@rpc("helloworld")
+def hello_world():
+    return "Hello World"
+
+# register signal 1
+@signal(1)
+def what_time_is_it(num):
+    print(time.asctime())
+
+# register signal 100
+@signal(100, target='workers')
+def what_time_is_it(num):
+    print("*** I AM THE WORKER %d AT %s ***" % (uwsgi.worker_id(), time.asctime()))
+
+
+# a 3 seconds timer
+@timer(3)
+def salut(num):
+    print("Salut !!! 3 seconds elapsed and signal %d raised" % num)
+
+# a 10 seconds red black timer (executed by the spooler)
+@rbtimer(10, target='spooler')
+def tenseconds(num):
+    print("red black timer !!! 10 seconds elapsed and signal %d raised" % num)
+
+# monitor /tmp directory
+@filemon("/tmp")
+def tmpmodified(num):
+    print("/tmp has been modified")
+
+
+# spool a long running task
+@spool
+def a_long_task(args):
+    for i in xrange(1,10):
+        print("%s = %d" % ( str(args), i))
+        time.sleep(1)
+
+# continuosly spool a long running task
+@spoolforever
+def an_infinite_task(args):
+    for i in xrange(1,4):
+        print("infinite: %d %s" % (i, str(args)))
+        time.sleep(1)
+
+
+# spool a task after 60 seconds
+@spool
+def delayed_task(args):
+    print("*** I am a delayed spool job. It is %s [%s]***" % (time.asctime(), str(args)))
+    # send a signal to all workers
+    uwsgi.signal(100)
+
+@spool
+def big_body_task(args):
+    print("*** managing a task with a body of %d bytes ***" % len(args['body']))
+    print(args['body'].swapcase()) 
+
+# run a task every hour
+@cron(59, -1, -1, -1, -1)
+def one_hour_passed(num):
+    print("received signal %d after 1 hour" % num)
+
+@thread
+def a_running_thread():
+    while True:
+        time.sleep(2)
+        print("i am a no-args thread")
+
+@thread
+def a_running_thread_with_args(who):
+    while True:
+        time.sleep(2)
+        print("Hello %s (from arged-thread)" % who)
+
+@postfork
+@thread
+def a_post_fork_thread():
+    while True:
+        time.sleep(3)
+        print("Hello from a thread in worker %d" % uwsgi.worker_id())
+
+@postfork
+def fork_happened():
+    print("fork() has been called [1]")
+
+@postfork
+def fork_happened2():
+    print("waiting for a signal...")
+    uwsgi.signal_wait()
+    print("signal received: %d" % 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)
+        print("[locked %d] waiting..." % uwsgi.worker_id())
+    print("done with locked function on worker %d" % uwsgi.worker_id())
+
+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)
+a_running_thread()
+a_running_thread_with_args("uWSGI")
+uwsgi_source_file = open('uwsgi.c','r')
+print(big_body_task.spool(priority=9,filename='uwsgi.c',body=uwsgi_source_file.read()))
+uwsgi_source_file.close()

django/uwsgitemplate.py

@@ -0,0 +1,29 @@
+from django.template.base import TemplateDoesNotExist
+from django.template.loader import BaseLoader
+from django.conf import settings
+
+try:
+    import uwsgi
+    on_uwsgi = True
+except:
+    on_uwsgi = False
+
+
+
+
+class Loader(BaseLoader):
+
+    is_usable = on_uwsgi
+
+    def symbolize(self, name):
+        return name.replace('.','_').replace('/','_').replace('-','_')
+
+    def load_template_source(self, template_name, template_dirs=None):
+        filename = 'templates_' + self.symbolize(template_name)
+        for app in settings.INSTALLED_APPS:
+            try:
+                symbol = "%s_%s" % (self.symbolize(app), filename)
+                return (uwsgi.embedded_data(symbol), "sym://%s" % symbol)
+            except:
+                pass
+        raise TemplateDoesNotExist(template_name)

emperor.c

@@ -6,37 +6,71 @@ extern struct uwsgi_server uwsgi;
 extern char **environ;
 
 int emperor_queue;
+char *emperor_absolute_dir;
+
+struct uwsgi_instance {
+        struct uwsgi_instance *ui_prev;
+        struct uwsgi_instance *ui_next;
+
+        char name[0xff];
+        pid_t pid;
+
+        int status;
+        time_t born;
+        time_t last_mod;
+        time_t last_loyal;
+
+        uint64_t respawns;
+        int use_config;
+
+        int pipe[2];
+        int pipe_config[2];
+
+        char *config;
+        uint32_t config_len;
+
+        int loyal;
+
+        int zerg;
+};
+
+
+struct uwsgi_instance *ui;
 
 static void royal_death(int signum) {
+
+
+	if (uwsgi.vassals_stop_hook) {
+
+		struct uwsgi_instance *c_ui = ui->ui_next;
+
+		while (c_ui) {
+                        uwsgi_log("running vassal stop-hook: %s %s\n", uwsgi.vassals_stop_hook, c_ui->name);
+			if (setenv("UWSGI_VASSALS_DIR", emperor_absolute_dir, 1)) {
+                                uwsgi_error("setenv()");
+                        }
+                        int stop_hook_ret = uwsgi_run_command_and_wait(uwsgi.vassals_stop_hook, c_ui->name);
+                        uwsgi_log("%s stop-hook returned %d\n", c_ui->name, stop_hook_ret);
+			c_ui = c_ui->ui_next;
+		}
+        }
 	uwsgi_notify("The Emperor is buried.");
 	exit(0);
 }
 
-struct uwsgi_instance {
-	struct uwsgi_instance *ui_prev;
-	struct uwsgi_instance *ui_next;
 
-	char name[0xff];
-	pid_t pid;
+void emperor_stats() {
 
-	int status;
-	time_t born;
-	time_t last_mod;
-	time_t last_loyal;
+	struct uwsgi_instance *c_ui = ui->ui_next;
 
-	uint64_t respawns;
-	int use_config;
+        while (c_ui) {
 
-	int pipe[2];
-	int pipe_config[2];
+		uwsgi_log("vassal instance %s (last modified %d) status %d loyal %d zerg %d\n",c_ui->name, c_ui->last_mod, c_ui->status, c_ui->loyal, c_ui->zerg);
 
-	char *config;
-	uint32_t config_len;
+                c_ui = c_ui->ui_next;
+        }
 
-	int loyal;
-};
-
-struct uwsgi_instance *ui;
+}
 
 struct uwsgi_instance *emperor_get_by_fd(int fd) {
 
@@ -84,8 +118,21 @@ void emperor_del(struct uwsgi_instance *c_ui) {
 		close(c_ui->pipe_config[0]);
 	}
 
+	if (uwsgi.vassals_stop_hook) {
+                        uwsgi_log("running vassal stop-hook: %s %s\n", uwsgi.vassals_stop_hook, c_ui->name);
+			if (setenv("UWSGI_VASSALS_DIR", emperor_absolute_dir, 1)) {
+                                uwsgi_error("setenv()");
+                        }
+                        int stop_hook_ret = uwsgi_run_command_and_wait(uwsgi.vassals_stop_hook, c_ui->name);
+                        uwsgi_log("%s stop-hook returned %d\n", c_ui->name, stop_hook_ret);
+                }
+
 	uwsgi_log("removed uwsgi instance %s\n", c_ui->name);
 
+	if (c_ui->zerg) {
+		uwsgi.emperor_broodlord_count--;
+	}
+
 	free(c_ui);
 
 }
@@ -131,6 +178,8 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	char *uef;
 	char **uenvs;
 	int counter;
+	char *colon = NULL;
+	int i;
 
 	sleep(1);
 
@@ -152,6 +201,12 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	uwsgi_log("c_ui->ui_next = %p\n", c_ui->ui_next);
 #endif
 	n_ui->ui_prev = c_ui;
+
+	if (strchr(name,':')) {
+		n_ui->zerg = 1;
+		uwsgi.emperor_broodlord_count++;
+	}
+
 	memcpy(n_ui->name, name, strlen(name));
 	n_ui->born = born;
 	n_ui->last_mod = born;
@@ -256,6 +311,13 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 		argv = uwsgi_malloc(sizeof(char *) * counter);
 		// set args
 		argv[0] = uwsgi.binary_path;
+
+		if (uwsgi.emperor_broodlord) {
+			colon = strchr(name, ':');
+			if (colon) {
+				colon[0] = 0;
+			}
+		}
 		if (!strcmp(name + (strlen(name) - 4), ".xml"))
 			argv[1] = "--xml";
 		if (!strcmp(name + (strlen(name) - 4), ".ini"))
@@ -266,6 +328,10 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			argv[1] = "--yaml";
 		if (!strcmp(name + (strlen(name) - 3), ".js"))
 			argv[1] = "--json";
+
+		if (colon) {
+			colon[0] = ':';
+		}
 		argv[2] = name;
 		counter = 3;
 		uct = uwsgi.vassals_templates;
@@ -276,6 +342,23 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			uct = uct->next;
 		}
 		argv[counter] = NULL;
+
+		// close all of the unneded fd
+		for(i=3;i<sysconf(_SC_OPEN_MAX);i++) {
+			if (i != n_ui->pipe[1]) {
+				close(i);
+			}
+		}
+
+		if (uwsgi.vassals_start_hook) {
+			uwsgi_log("running vassal start-hook: %s %s\n", uwsgi.vassals_start_hook, n_ui->name);
+			if (setenv("UWSGI_VASSALS_DIR", emperor_absolute_dir, 1)) {
+				uwsgi_error("setenv()");
+			}
+			int start_hook_ret = uwsgi_run_command_and_wait(uwsgi.vassals_start_hook, n_ui->name);
+			uwsgi_log("%s start-hook returned %d\n", n_ui->name, start_hook_ret);
+		}
+
 		// start !!!
 		if (execvp(argv[0], argv)) {
 			uwsgi_error("execvp()");
@@ -320,6 +403,8 @@ void emperor_loop() {
 	signal(SIGPIPE, SIG_IGN);
 	uwsgi_unix_signal(SIGINT, royal_death);
         uwsgi_unix_signal(SIGTERM, royal_death);
+        uwsgi_unix_signal(SIGQUIT, royal_death);
+        uwsgi_unix_signal(SIGUSR1, emperor_stats);
 
 	memset(&ui_base, 0, sizeof(struct uwsgi_instance));
 
@@ -328,7 +413,12 @@ void emperor_loop() {
 
         events = event_queue_alloc(64);
 
-	uwsgi_log("*** starting uWSGI Emperor ***\n");
+	if (uwsgi.has_emperor) {
+		uwsgi_log("*** starting uWSGI sub-Emperor ***\n");
+	}
+	else {
+		uwsgi_log("*** starting uWSGI Emperor ***\n");
+	}
 
 	amqp_port = strchr(uwsgi.emperor_dir, ':');
 
@@ -356,7 +446,7 @@ reconnect:
 		event_queue_add_fd_read(emperor_queue, amqp_fd);
 	}
 	else {
-		if (!glob(uwsgi.emperor_dir, GLOB_MARK, NULL, &g)) {
+		if (!glob(uwsgi.emperor_dir, GLOB_MARK|GLOB_NOCHECK, NULL, &g)) {
 			if (g.gl_pathc == 1 && g.gl_pathv[0][strlen(g.gl_pathv[0]) - 1] == '/') {
 				simple_mode = 1;
 				if (chdir(uwsgi.emperor_dir)) {
@@ -369,6 +459,7 @@ reconnect:
 			uwsgi_error("glob()");
 			exit(1);
 		}
+		emperor_absolute_dir = realpath(".", NULL);
 	}
 
 	ui = &ui_base;
@@ -397,6 +488,7 @@ reconnect:
 				
 				if (!config) {
 					uwsgi_log("problem with RabbitMQ server, trying reconnection...\n");
+					event_queue_del_fd(emperor_queue, amqp_fd, event_queue_read());
 					close(amqp_fd);
 					amqp_fd = -1;
 					goto reconnect;
@@ -416,6 +508,7 @@ reconnect:
 						ui_current->config = config;
 						ui_current->config_len = msgsize;
 						if (!msgsize) {
+							// SAFE
 							emperor_del(ui_current);
 						}
 						else {
@@ -474,6 +567,7 @@ reconnect:
 					char byte;
 					ssize_t rlen = read(interesting_fd, &byte, 1);
 					if (rlen <= 0) {
+						// SAFE
 						emperor_del(ui_current);
 					}
 					else {
@@ -483,10 +577,20 @@ reconnect:
 							
 							// TODO post-start hook
 						}
+						else if (byte == 22) {
+							emperor_stop(ui_current);
+						}
+						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);
+							free(zerg_name);
+						}
 					}
 				}
 				else {
 					uwsgi_log("unrecognized event on fd %d\n", interesting_fd);
+					event_queue_del_fd(emperor_queue, interesting_fd, event_queue_read());
 					close(interesting_fd);
 				}
 			}
@@ -529,7 +633,7 @@ reconnect:
 			closedir(dir);
 		}
 		else {
-			if (glob(uwsgi.emperor_dir, GLOB_MARK, NULL, &g)) {
+			if (glob(uwsgi.emperor_dir, GLOB_MARK|GLOB_NOCHECK, NULL, &g)) {
 				uwsgi_error("glob()");
 				continue;
 			}
@@ -602,25 +706,29 @@ reconnect:
 			if (amqp_fd > -1) {
 				if (!ui_current->loyal && (time(NULL)-ui_current->last_loyal) > 60) {
 					uwsgi_log("!!! no loyalty showed by instance %s !!!\n", ui_current->name);
+					// SAFE
 					emperor_del(ui_current);
 					break;
 				}
 			}
 			if (ui_current->status == 1) {
 				if (ui_current->config) free(ui_current->config);
+				// SAFE
 				emperor_del(ui_current);
 				break;
 			}
-			else if (!ui_current->use_config && strncmp(ui_current->name, "http://",7) && stat(ui_current->name, &st)) {
+			else if (!ui_current->use_config && strncmp(ui_current->name, "http://",7) && stat(ui_current->name, &st) && !ui_current->zerg) {
 				emperor_stop(ui_current);
 			}
 			else if (ui_current->pid == diedpid) {
 				if (ui_current->status == 0) {
 					// respawn an accidentally dead instance if its exit code is not UWSGI_EXILE_CODE
 					if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_EXILE_CODE) {
+						// SAFE
 						emperor_del(ui_current);
 					}
 					else {
+						// UNSAFE
 						emperor_add(ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len);
 						emperor_del(ui_current);
 					}
@@ -629,6 +737,7 @@ reconnect:
 				else if (ui_current->status == 1) {
 					// remove 'marked for dead' instance
 					if (ui_current->config) free(ui_current->config);
+					// SAFE
 					emperor_del(ui_current);
 					break;
 				}

event.c

@@ -591,7 +591,9 @@ int event_queue_add_file_monitor(int eq, char *filename, int *id) {
 
 	*id = inotify_add_watch(ifd, filename, IN_ATTRIB|IN_CREATE|IN_DELETE|IN_DELETE_SELF|IN_MODIFY|IN_MOVE_SELF|IN_MOVED_FROM|IN_MOVED_TO);
 		
+#ifdef UWSGI_DEBUG
 	uwsgi_log("added watch %d for filename %s\n", *id, filename);
+#endif
 
 	if (add_to_queue) {
 		return event_queue_add_fd_read(eq, ifd);
@@ -630,7 +632,9 @@ struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
 	}
 	else {
 		items = isize/(sizeof(struct inotify_event));
+#ifdef UWSGI_DEBUG
 		uwsgi_log("inotify returned %d items\n", items);
+#endif
 		for(j=0;j<items;j++) {	
 			iie = &bie[j];
 			for(i=0;i<ushared->files_monitored_cnt;i++) {
@@ -816,8 +820,6 @@ int event_queue_add_timer(int eq, int *id, int sec) {
 	*id = timer_id ;
 	timer_id++;	
 
-	uwsgi_log("registering timer %d\n", sec);
-	
         EV_SET(&kev, *id, EVFILT_TIMER, EV_ADD, 0, sec*1000, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
                 uwsgi_error("kevent()");

flaskpost.py

@@ -0,0 +1,12 @@
+from flask import Flask, request
+app = Flask(__name__)
+app.debug = True
+
+@app.route('/')
+def hello_world():
+    return "<form method='POST' enctype='multipart/form-data' action='/upload'><input type='text' name='pippo'/><input type='file' name='ufile'/><input type='submit' value='upload'/></form>"
+
+@app.route('/upload',  methods=['GET', 'POST'])
+def upload_file():
+    return str(len(request.form.get('pippo', 'boh'))) + request.form.get('pippo', 'boh')
+    return request.files['ufile'].read()

hello_world.py

@@ -0,0 +1,5 @@
+import uwsgi
+uwsgi.cache_set('/', "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nHello World from cache")
+def application(env, start_response):
+    start_response('200 OK', [('Content-Type', 'text/html')])
+    return "<h1>Hello World</h1>"

ini.c

@@ -67,6 +67,11 @@ char *ini_get_line(char *ini, off_t size) {
 		}
 	}
 
+	// check if it is a stupid file without \n at the end
+	if (ptr > ini) {
+		return ptr;
+	}
+
 	return NULL;
 
 }
@@ -102,7 +107,9 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 		}
 	}
 
-	uwsgi_log("[uWSGI] getting INI configuration from %s\n", file);
+	if (file[0] != 0) {
+		uwsgi_log("[uWSGI] getting INI configuration from %s\n", file);
+	}
 
 	ini = uwsgi_open_and_read(file, &len, 1, magic_table);
 
@@ -143,6 +150,11 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 
 	}
 
+	if (colon) {
+		colon[0] = ':';
+	}
+
+
 }
 
 #endif

it.unbit.uwsgi.emperor.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+        <key>Label</key>
+        <string>it.unbit.uwsgi.emperor</string>
+	<key>ProgramArguments</key>
+        <array>
+        	<string>/Users/roberta/uwsgi/uwsgi</string>
+                <string>--emperor</string>
+		<string>/Users/*/Library/uwsgi/*.{xml,ini,yml,yaml,js}</string>
+	</array>
+</dict>
+</plist>

it.unbit.uwsgi.plist

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+        <key>Label</key>
+        <string>it.unbit.uwsgi</string>
+	<key>ProgramArguments</key>
+        <array>
+        	<string>/Users/roberta/uwsgi/uwsgi</string>
+                <string>--socket</string>
+		<string>:3032</string>
+		<string>--module</string>
+		<string>welcome</string>
+		<string>--master</string>
+		<string>--die-on-term</string>
+	</array>
+</dict>
+</plist>

lib/netlink.c

@@ -4,7 +4,7 @@
 #include <linux/rtnetlink.h>
 #include <net/if.h>
 
-#ifdef IFLA_NET_NS_PID
+#ifdef CLONE_NEWNET
 
 #define NLMSG_TAIL(nmsg) \
         ((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))

lib/rbtree.c

@@ -25,6 +25,16 @@
 
 #include "../uwsgi.h"
 
+static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
+{
+        rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
+}
+static inline void rb_set_color(struct rb_node *rb, int color)
+{
+        rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
+}
+
+
 static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
 {
 	struct rb_node *right = node->rb_right;
@@ -282,3 +292,18 @@ void rb_erase(struct rb_node *node, struct rb_root *root)
 	if (color == RB_BLACK)
 		__rb_erase_color(child, parent, root);
 }
+
+#ifdef __clang__
+void rb_link_node(struct rb_node * node, struct rb_node * parent,
+                                struct rb_node ** rb_link)
+#else
+inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
+                                struct rb_node ** rb_link)
+#endif
+{
+        node->rb_parent_color = (unsigned long )parent;
+        node->rb_left = node->rb_right = NULL;
+
+        *rb_link = node;
+}
+

lib/rbtree.h

@@ -37,7 +37,6 @@ struct rb_root
 	struct rb_node *rb_node;
 };
 
-
 #define rb_parent(r)   ((struct rb_node *)((r)->rb_parent_color & ~3))
 #define rb_color(r)   ((r)->rb_parent_color & 1)
 #define rb_is_red(r)   (!rb_color(r))
@@ -45,24 +44,13 @@ struct rb_root
 #define rb_set_red(r)  do { (r)->rb_parent_color &= ~1; } while (0)
 #define rb_set_black(r)  do { (r)->rb_parent_color |= 1; } while (0)
 
-static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
-{
-	rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
-}
-static inline void rb_set_color(struct rb_node *rb, int color)
-{
-	rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
-}
-
 void rb_insert_color(struct rb_node *, struct rb_root *);
 void rb_erase(struct rb_node *, struct rb_root *);
 
-static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
-                                struct rb_node ** rb_link)
-{
-        node->rb_parent_color = (unsigned long )parent;
-        node->rb_left = node->rb_right = NULL;
-
-        *rb_link = node;
-}
-
+#ifdef __clang__
+void rb_link_node(struct rb_node *, struct rb_node *,
+                                struct rb_node **);
+#else
+inline void rb_link_node(struct rb_node *, struct rb_node *,
+                                struct rb_node **);
+#endif

logging.c

@@ -173,6 +173,8 @@ void get_memusage() {
 
 #if defined(__FreeBSD__)
 	kv = kvm_open(NULL, "/dev/null", NULL, O_RDONLY, NULL);
+#elif defined(__NetBSD__) || defined(__OpenBSD__)
+	kv = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, NULL);
 #else
 	kv = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
 #endif

loop.c

@@ -66,23 +66,20 @@ void *simple_loop(void *arg1) {
 #endif
 
 	// initialize the main event queue to monitor sockets
-	uwsgi.main_queue = event_queue_init();
+	int main_queue = event_queue_init();
 
-	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
-	while(uwsgi_sock) {
-		event_queue_add_fd_read(uwsgi.main_queue, uwsgi_sock->fd);
-		uwsgi_sock = uwsgi_sock->next;
-	}
+	uwsgi_add_sockets_to_queue(main_queue);
 
 	if (uwsgi.signal_socket > -1) {
-		event_queue_add_fd_read(uwsgi.main_queue, uwsgi.signal_socket);
+		event_queue_add_fd_read(main_queue, uwsgi.signal_socket);
+		event_queue_add_fd_read(main_queue, uwsgi.my_signal_socket);
 	}
 
 	while (uwsgi.workers[uwsgi.mywid].manage_next_request) {
 
 		wsgi_req_setup(wsgi_req, core_id, NULL);
 
-		if (wsgi_req_accept(wsgi_req)) {
+		if (wsgi_req_accept(main_queue, wsgi_req)) {
 			continue;
 		}
 
@@ -94,9 +91,19 @@ void *simple_loop(void *arg1) {
 		uwsgi_close_request(wsgi_req);
 	}
 
-	pthread_exit(NULL);
-
-	//never here
+	// end of the loop
+	if (uwsgi.workers[uwsgi.mywid].destroy && uwsgi.workers[0].pid > 0) {
+#ifdef __APPLE__
+		kill(uwsgi.workers[0].pid, SIGTERM);
+#else
+		if (uwsgi.propagate_touch) {
+			kill(uwsgi.workers[0].pid, SIGHUP);
+		}
+		else {
+			gracefully_kill(0);
+		}
+#endif
+	}
 	return NULL;
 }
 
@@ -109,7 +116,7 @@ void *zeromq_loop(void *arg1) {
 
 	struct wsgi_request *wsgi_req = uwsgi.wsgi_requests[core_id];
 	uwsgi.zeromq_recv_flag = 0;
-	zmq_pollitem_t zmq_poll_items[2];
+	zmq_pollitem_t zmq_poll_items[3];
 	char uwsgi_signal;
 
 	if (uwsgi.threads > 1) {
@@ -153,6 +160,10 @@ void *zeromq_loop(void *arg1) {
 		zmq_poll_items[1].socket = NULL;
 		zmq_poll_items[1].fd = uwsgi.signal_socket;
 		zmq_poll_items[1].events = ZMQ_POLLIN;
+
+		zmq_poll_items[2].socket = NULL;
+		zmq_poll_items[2].fd = uwsgi.my_signal_socket;
+		zmq_poll_items[2].events = ZMQ_POLLIN;
 	}
 
 
@@ -165,7 +176,7 @@ void *zeromq_loop(void *arg1) {
 
 
 		if (uwsgi.signal_socket > -1) {
-			if (zmq_poll(zmq_poll_items, 2, -1) < 0) {
+			if (zmq_poll(zmq_poll_items, 3, -1) < 0) {
 				uwsgi_error("zmq_poll()");
 				continue;
 			}
@@ -178,7 +189,9 @@ void *zeromq_loop(void *arg1) {
                         		}
                 		}
                 		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);
                         		}
@@ -186,6 +199,26 @@ void *zeromq_loop(void *arg1) {
 				continue;
 			}
 
+			if (zmq_poll_items[2].revents & ZMQ_POLLIN) {
+                                if (read(uwsgi.my_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);
+                                        }
+                                }
+                                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);
+                                        }
+                                }
+                                continue;
+                        }
+
+			
+
 			if (zmq_poll_items[0].revents & ZMQ_POLLIN) {
 				wsgi_req->poll.fd = wsgi_req->socket->proto_accept(wsgi_req, uwsgi.zmq_socket->fd);
 			}
@@ -202,8 +235,7 @@ void *zeromq_loop(void *arg1) {
 	}
 
 
-	pthread_exit(NULL);
-        //never here
+        // end of the loop
         return NULL;
 }
 #endif

master.c

@@ -2,6 +2,17 @@
 
 extern struct uwsgi_server uwsgi;
 
+void uwsgi_restore_auto_snapshot(int signum) {
+
+	if (uwsgi.workers[1].snapshot > 0) {
+		uwsgi.restore_snapshot = 1;
+	}
+	else {
+		uwsgi_log("[WARNING] no snapshot available\n");
+	}
+	
+}
+
 void expire_rb_timeouts(struct rb_root *root) {
 
         time_t current = time(NULL);
@@ -31,32 +42,24 @@ void expire_rb_timeouts(struct rb_root *root) {
         }
 }
 
-
-void uwsgi_subscribe(char *subscription) {
-
+void uwsgi_send_subscription(char *udp_address, char *key, size_t keysize, char *modifier1, size_t modifier1_len) {
 	char *ssb;
 	char subscrbuf[4096];
+
 	uint16_t ustrlen;
 
-	char *udp_address = strchr(subscription,':');
-        if (!udp_address) return;
+	ssb = subscrbuf;
 
-        char *subscription_key = strchr(udp_address+1, ':');
-	if (!subscription_key) return;
-        udp_address = uwsgi_concat2n(subscription, subscription_key-subscription, "", 0);
-
-        ssb = subscrbuf;
-
-	ustrlen = 3;
+        ustrlen = 3;
         *ssb++ = (uint8_t) (ustrlen  & 0xff);
         *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
         memcpy(ssb, "key", ustrlen);
         ssb+=ustrlen;
 
-        ustrlen = strlen(subscription_key+1);
+        ustrlen = keysize;
         *ssb++ = (uint8_t) (ustrlen  & 0xff);
         *ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
-        memcpy(ssb, subscription_key+1, ustrlen);
+        memcpy(ssb, key, ustrlen);
         ssb+=ustrlen;
 
         ustrlen = 7;
@@ -71,8 +74,106 @@ void uwsgi_subscribe(char *subscription) {
         memcpy(ssb, uwsgi.sockets->name, ustrlen);
         ssb+=ustrlen;
 
+	if (modifier1) {
+		ustrlen = 9;
+        	*ssb++ = (uint8_t) (ustrlen  & 0xff);
+        	*ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        	memcpy(ssb, "modifier1", ustrlen);
+        	ssb+=ustrlen;
+
+        	ustrlen = modifier1_len;
+        	*ssb++ = (uint8_t) (ustrlen  & 0xff);
+        	*ssb++ = (uint8_t) ((ustrlen >>8) & 0xff);
+        	memcpy(ssb, modifier1, ustrlen);
+        	ssb+=ustrlen;
+	}
+
         send_udp_message(224, udp_address, subscrbuf, ssb-subscrbuf);
-	free(udp_address);
+}
+
+void uwsgi_subscribe(char *subscription) {
+
+	int subfile_size;
+	int i;
+	char *key = NULL;
+	int keysize = 0;
+	char *modifier1 = NULL;
+	int modifier1_len = 0;
+
+	char *udp_address = strchr(subscription,':');
+        if (!udp_address) return;
+
+        char *subscription_key = strchr(udp_address+1, ':');
+	if (!subscription_key) return;
+
+        udp_address = uwsgi_concat2n(subscription, subscription_key-subscription, "", 0);
+
+	if (subscription_key[1] == '@') {
+		if (!uwsgi_file_exists(subscription_key+2)) goto clear;
+		char *lines = uwsgi_open_and_read(subscription_key+2, &subfile_size, 1, NULL);
+		if (subfile_size > 0) {
+			key = lines;
+			for(i=0;i<subfile_size;i++) {
+				if (lines[i] == 0) {
+					if (keysize > 0) {
+						if (key[0] != '#' && key[0] != '\n') {
+							modifier1 = strchr(key, ':');
+                					if (modifier1) {
+                        					modifier1[0] = 0;
+                        					modifier1++;
+                        					modifier1_len = strlen(modifier1);
+								keysize = strlen(key);
+                					}
+							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len);
+							modifier1 = NULL;
+							modifier1_len = 0;
+						}
+					}	
+					break;
+				}
+				else if (lines[i] == '\n') {
+					if (keysize > 0) {
+						if (key[0] != '#' && key[0] != '\n') {
+							lines[i] = 0;
+							modifier1 = strchr(key, ':');
+                					if (modifier1) {
+                        					modifier1[0] = 0;
+                        					modifier1++;
+                        					modifier1_len = strlen(modifier1);
+								keysize = strlen(key);
+                					}
+							uwsgi_send_subscription(udp_address, key, keysize, modifier1, modifier1_len);
+							modifier1 = NULL;
+							modifier1_len = 0;
+							lines[i] = '\n';
+						}
+					}
+					key = lines+i+1;
+					keysize = 0;
+					continue;
+				}
+				keysize++;
+			}
+
+			free(lines);
+		}
+	}
+	else {
+		modifier1 = strchr(subscription_key+1, ':');
+		if (modifier1) {
+			modifier1[0] = 0;
+			modifier1++;
+			modifier1_len = strlen(modifier1);
+		}
+
+		uwsgi_send_subscription(udp_address, subscription_key+1, strlen(subscription_key+1), modifier1, modifier1_len);
+		if (modifier1)
+			modifier1[-1] = ':';
+	}
+
+clear:
+
+        free(udp_address);
 
 }
 
@@ -85,8 +186,23 @@ void get_linux_tcp_info(int fd) {
 		if (!uwsgi.shared->ti.tcpi_sacked) {
 			return;
 		}
+
+		uwsgi.shared->options[UWSGI_OPTION_BACKLOG_STATUS] = uwsgi.shared->ti.tcpi_unacked;
+		if (uwsgi.vassal_sos_backlog > 0 && uwsgi.has_emperor) {
+			if ((int)uwsgi.shared->ti.tcpi_unacked >= uwsgi.vassal_sos_backlog) {
+				// ask emperor for help
+				char byte = 30;
+                		if (write(uwsgi.emperor_fd, &byte, 1) != 1) {
+                        		uwsgi_error("write()");
+                		}
+				else {
+					uwsgi_log("asking emperor for reinforcements (backlog: %d)...\n", (int) uwsgi.shared->ti.tcpi_unacked);
+				}
+			}
+		}
 		if (uwsgi.shared->ti.tcpi_unacked >= uwsgi.shared->ti.tcpi_sacked) {
 			uwsgi_log_verbose("*** uWSGI listen queue of socket %d full !!! (%d/%d) ***\n", fd, uwsgi.shared->ti.tcpi_unacked, uwsgi.shared->ti.tcpi_sacked);
+			uwsgi.shared->options[UWSGI_OPTION_BACKLOG_ERRORS]++;
 		}
 	}
 }
@@ -96,7 +212,10 @@ void manage_cluster_announce(char *key, uint16_t keylen, char *val, uint16_t val
 
 	char *tmpstr;
 	struct uwsgi_cluster_node *ucn = (struct uwsgi_cluster_node *) data;
+
+#ifdef UWSGI_DEBUG
 	uwsgi_log("%.*s = %.*s\n", keylen, key, vallen, val);
+#endif
 
 	if (!uwsgi_strncmp("hostname", 8, key, keylen)) {
 		strncpy(ucn->nodename, val, UMIN(vallen, 255));
@@ -121,16 +240,14 @@ void manage_cluster_announce(char *key, uint16_t keylen, char *val, uint16_t val
 
 void master_loop(char **argv, char **environ) {
 
-	uint64_t master_cycles = 0;
 	uint64_t tmp_counter;
 
 	char log_buf[4096];
 
-	time_t current_time = time(NULL);
 
 	struct timeval last_respawn;
+	int last_respawn_rate = 0;
 
-	pid_t pid;
 	int pid_found = 0;
 
 	pid_t diedpid;
@@ -143,6 +260,9 @@ void master_loop(char **argv, char **environ) {
 
 	uint8_t uwsgi_signal;
 
+	time_t last_request_timecheck = 0;
+	uint64_t last_request_count = 0;
+
 #ifdef UWSGI_UDP
 	struct sockaddr_in udp_client;
 	socklen_t udp_len;
@@ -172,8 +292,8 @@ void master_loop(char **argv, char **environ) {
 
 	struct uwsgi_rb_timer *min_timeout;
 	struct rb_root *rb_timers = uwsgi_init_rb_timer();
-	struct tm *uwsgi_cron_delta;
 
+	uwsgi.current_time = time(NULL);
 
 	uwsgi_unix_signal(SIGHUP, grace_them_all);
 	if (uwsgi.die_on_term) {
@@ -186,7 +306,9 @@ void master_loop(char **argv, char **environ) {
 	}
 	uwsgi_unix_signal(SIGINT, kill_them_all);
 	uwsgi_unix_signal(SIGUSR1, stats);
-
+	if (uwsgi.auto_snapshot) {
+		uwsgi_unix_signal(SIGURG, uwsgi_restore_auto_snapshot);
+	}
 
 	uwsgi.master_queue = event_queue_init();
 
@@ -209,6 +331,12 @@ void master_loop(char **argv, char **environ) {
 	if (uwsgi.has_emperor) {
 		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.emperor_fd);
 	}
+
+	if (uwsgi.zerg_server) {
+		uwsgi.zerg_server_fd = bind_to_unix(uwsgi.zerg_server, uwsgi.listen_queue, 0, 0);
+		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.zerg_server_fd);
+		uwsgi_log("*** Zerg server enabled on %s ***\n", uwsgi.zerg_server);
+	}
 #ifdef UWSGI_UDP
 	if (uwsgi.udp_socket) {
 		udp_fd = bind_to_udp(uwsgi.udp_socket, 0, 0);
@@ -220,6 +348,12 @@ void master_loop(char **argv, char **environ) {
 			event_queue_add_fd_read(uwsgi.master_queue, udp_fd);
 		}
 	}
+
+	if (uwsgi.cheap) {
+		uwsgi_add_sockets_to_queue(uwsgi.master_queue);
+		uwsgi_log("cheap mode enabled: waiting for socket connection...\n");
+	}
+
 #ifdef UWSGI_MULTICAST
 	if (uwsgi.cluster) {
 
@@ -382,29 +516,46 @@ void master_loop(char **argv, char **environ) {
 				}
 			}
 		}
-		if (ready_to_die >= uwsgi.numproc && uwsgi.to_hell) {
-#ifdef UWSGI_SPOOLER
-			if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
-				kill(uwsgi.shared->spooler_pid, SIGKILL);
-				uwsgi_log( "killed the spooler with pid %d\n", uwsgi.shared->spooler_pid);
+		if (uwsgi.respawn_workers) {
+			for(i=1;i<=uwsgi.numproc;i++) {
+				if (uwsgi_respawn_worker(i)) return;
 			}
 
-#endif
+			uwsgi.respawn_workers = 0;
+		}
+		if (uwsgi.restore_snapshot) {
+			uwsgi_log("[snapshot] restoring workers...\n");
+			for(i=1;i<=uwsgi.numproc;i++) {
+				if (uwsgi.workers[i].pid == 0) continue;
+				kill(uwsgi.workers[i].pid, SIGKILL);
+				if (waitpid(uwsgi.workers[i].pid, &waitpid_status, 0) < 0) {
+                                	uwsgi_error("waitpid()");
+                                }
+				if (uwsgi.auto_snapshot > 0 && i > uwsgi.auto_snapshot) {
+					uwsgi.workers[i].pid = 0;
+					uwsgi.workers[i].snapshot = 0;
+				}
+				else {
+					uwsgi.workers[i].pid = uwsgi.workers[i].snapshot;
+					uwsgi.workers[i].snapshot = 0;
+					kill(uwsgi.workers[i].pid, SIGURG);
+					uwsgi_log( "Restored uWSGI worker %d (pid: %d)\n", i, (int) uwsgi.workers[i].pid);
+				}
+			}
+
+			uwsgi.restore_snapshot = 0;
+			continue;
+		}
+		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++) {
+				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
+			}
 
-			// TODO kill all the gateways
 			uwsgi_log( "goodbye to uWSGI.\n");
 			exit(0);
 		}
-		if (ready_to_reload >= uwsgi.numproc && uwsgi.to_heaven) {
-#ifdef UWSGI_SPOOLER
-			if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
-				kill(uwsgi.shared->spooler_pid, SIGKILL);
-				uwsgi_log( "wait4() the spooler with pid %d...", uwsgi.shared->spooler_pid);
-				diedpid = waitpid(uwsgi.shared->spooler_pid, &waitpid_status, 0);
-				uwsgi_log( "done.");
-			}
-#endif
-
+		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++) {
 				diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
@@ -460,14 +611,17 @@ void master_loop(char **argv, char **environ) {
 			exit(1);
 		}
 
-		if (uwsgi.numproc > 0 || uwsgi.gateways_cnt > 0 || ushared->daemons_cnt > 0) {
-			master_has_children = 1;
-		}
+		if (!uwsgi.cheap) {
+
+			if (uwsgi.numproc > 0 || uwsgi.gateways_cnt > 0 || ushared->daemons_cnt > 0) {
+				master_has_children = 1;
+			}
 #ifdef UWSGI_SPOOLER
-		if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
-			master_has_children = 1;
-		}
+			if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
+				master_has_children = 1;
+			}
 #endif
+		}
 
 		if (!master_has_children) {
 			diedpid = 0;
@@ -555,70 +709,11 @@ void master_loop(char **argv, char **environ) {
 			
 				// check uwsgi-cron table
 				if (ushared->cron_cnt) {
-					current_time = time(NULL);
-					uwsgi_cron_delta = localtime( &current_time );
+					uwsgi_manage_signal_cron(time(NULL));
+				}
 
-					if (uwsgi_cron_delta) {
-
-						// fix month
-						uwsgi_cron_delta->tm_mon++;
-
-						uwsgi_lock(uwsgi.cron_table_lock);
-						for(i=0;i<ushared->cron_cnt;i++) {
-	
-							struct uwsgi_cron *ucron = &ushared->cron[i];
-							int uc_minute, uc_hour, uc_day, uc_month, uc_week;
-
-							uc_minute = ucron->minute;
-							uc_hour = ucron->hour;
-							uc_day = ucron->day;
-							uc_month = ucron->month;
-							uc_week = ucron->week;
-	
-							if (ucron->minute == -1) uc_minute = uwsgi_cron_delta->tm_min;
-							if (ucron->hour == -1) uc_hour = uwsgi_cron_delta->tm_hour;
-							if (ucron->month == -1) uc_month = uwsgi_cron_delta->tm_mon;
-
-							// mday and wday are ORed
-							if (ucron->day == -1 && ucron->week == -1) {
-								if (ucron->day == -1) uc_day = uwsgi_cron_delta->tm_mday;
-								if (ucron->week == -1) uc_week = uwsgi_cron_delta->tm_wday;
-							}
-							else if (ucron->day == -1) {
-								ucron->day = uwsgi_cron_delta->tm_mday;
-							}
-							else if (ucron->week == -1) {
-								ucron->week = uwsgi_cron_delta->tm_wday;
-							}
-							else {
-								if (ucron->day == uwsgi_cron_delta->tm_mday) {
-									ucron->week = uwsgi_cron_delta->tm_wday;
-								}
-								else if (ucron->week == uwsgi_cron_delta->tm_wday) {
-									ucron->day = uwsgi_cron_delta->tm_mday;
-								}
-							}
-							
-							if (uwsgi_cron_delta->tm_min == uc_minute &&
-								uwsgi_cron_delta->tm_hour == uc_hour &&
-								uwsgi_cron_delta->tm_mon == uc_month &&
-								uwsgi_cron_delta->tm_mday == uc_day &&
-								uwsgi_cron_delta->tm_wday == uc_week) {
-
-
-								// date match, signal it ?
-								if (current_time - ucron->last_job > 60) {
-									uwsgi_route_signal(ucron->sig);
-									ucron->last_job = current_time;
-								}
-							}
-					
-						}
-						uwsgi_unlock(uwsgi.cron_table_lock);
-					}
-					else {
-						uwsgi_error("localtime()");
-					}
+				if (uwsgi.crons) {
+					uwsgi_manage_command_cron(time(NULL));
 				}
 
 				if (rlen > 0) {
@@ -640,17 +735,70 @@ void master_loop(char **argv, char **environ) {
                                                                         }
                                                                 }
 #endif
+								else if (uwsgi.log_socket) {
+									sendto(uwsgi.log_socket_fd, log_buf, rlen, 0, &uwsgi.log_socket_addr->sa, uwsgi.log_socket_size);
+								}
 								// TODO allow uwsgi.logger = func
 							}	
 						}
 					}
 
+					if (uwsgi.zerg_server) {
+						if (interesting_fd == uwsgi.zerg_server_fd) {
+							struct sockaddr_un zsun;
+							socklen_t zsun_len = sizeof(struct sockaddr_un);
+							int zerg_client = accept(uwsgi.zerg_server_fd, (struct sockaddr *) &zsun, &zsun_len);
+							if (zerg_client < 0) {
+								uwsgi_error("zerg: accept()");
+								continue;
+							}
+
+							struct msghdr zerg_msg;
+							void *zerg_msg_control = uwsgi_malloc(CMSG_SPACE (sizeof (int) * uwsgi_count_sockets(uwsgi.sockets)));
+							struct iovec zerg_iov;
+							struct cmsghdr *cmsg;
+
+							zerg_iov.iov_base = "uwsgi-zerg";
+                        				zerg_iov.iov_len = 10;
+
+							zerg_msg.msg_name    = NULL;
+                                        		zerg_msg.msg_namelen = 0;
+                                        		zerg_msg.msg_iov     = &zerg_iov;
+                                        		zerg_msg.msg_iovlen  = 1;
+                                        		zerg_msg.msg_flags   = 0;
+                                        		zerg_msg.msg_control    = zerg_msg_control;
+                                        		zerg_msg.msg_controllen = CMSG_SPACE (sizeof (int) * uwsgi_count_sockets(uwsgi.sockets));
+
+                                        		cmsg = CMSG_FIRSTHDR (&zerg_msg);
+                                        		cmsg->cmsg_len   = CMSG_LEN (sizeof (int) * uwsgi_count_sockets(uwsgi.sockets));
+                                        		cmsg->cmsg_level = SOL_SOCKET;
+                                        		cmsg->cmsg_type  = SCM_RIGHTS;
+
+							struct uwsgi_socket *uwsgi_sock = uwsgi.sockets; 
+							unsigned char *zerg_fd_ptr = CMSG_DATA(cmsg);
+							while(uwsgi_sock) {
+								memcpy(zerg_fd_ptr, &uwsgi_sock->fd, sizeof(int));
+								zerg_fd_ptr += sizeof(int);
+								uwsgi_sock = uwsgi_sock->next;
+							}
+
+                                        		if (sendmsg(zerg_client, &zerg_msg, 0) < 0) {
+                                                		uwsgi_error("sendmsg()");
+                                        		}
+
+
+                                        		close(zerg_client);
+
+							free(zerg_msg_control);
+						}
+					}
+
 					if (uwsgi.has_emperor) {
 						if (interesting_fd == uwsgi.emperor_fd) {
 							char byte;
 							rlen = read(uwsgi.emperor_fd, &byte, 1);
                                                         if (rlen > 0) {
-								uwsgi_log("received message %d from emperor\n", byte);
+								uwsgi_log_verbose("received message %d from emperor\n", byte);
 								// remove me
 								if (byte == 0) {
 									close(uwsgi.emperor_fd);
@@ -670,6 +818,25 @@ void master_loop(char **argv, char **environ) {
 							}
 						}
 					}
+
+
+					if (uwsgi.cheap) {
+						int found = 0 ;
+						struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+						while(uwsgi_sock) {
+							if (interesting_fd == uwsgi_sock->fd) {
+								found = 1;
+								uwsgi.cheap = 0;
+								uwsgi_del_sockets_from_queue(uwsgi.master_queue);
+								for(i=1;i<=uwsgi.numproc;i++) {
+									if (uwsgi_respawn_worker(i)) return;		
+								}
+								break;
+							}
+							uwsgi_sock = uwsgi_sock->next;
+						}
+						if (found) continue;
+					}
 #ifdef UWSGI_SNMP
 					if (uwsgi.snmp_addr && interesting_fd == snmp_fd) {
 						udp_len = sizeof(udp_client);
@@ -821,7 +988,9 @@ void master_loop(char **argv, char **environ) {
 							uwsgi_error("read()");
 						}	
 						else if (rlen > 0) {
-							uwsgi_log("received uwsgi signal %d from workers\n", uwsgi_signal);
+#ifdef UWSGI_DEBUG
+							uwsgi_log_verbose("received uwsgi signal %d from a worker\n", uwsgi_signal);
+#endif
 							uwsgi_route_signal(uwsgi_signal);
 						}
 						else {
@@ -832,7 +1001,7 @@ void master_loop(char **argv, char **environ) {
 					}
 				}
 
-			current_time = time(NULL);	
+			uwsgi.current_time = time(NULL);	
 			// checking logsize
 			if (uwsgi.logfile) {
 				uwsgi.shared->logsize = lseek(2, 0, SEEK_CUR);
@@ -850,25 +1019,62 @@ void master_loop(char **argv, char **environ) {
 			}
 
 				
-			master_cycles++;
+			uwsgi.master_cycles++;
 
 			// recalculate requests counter on race conditions risky configurations
 			// a bit of inaccuracy is better than locking;)
 
 			if (uwsgi.numproc > 1) {
 				tmp_counter = 0;
-				for(i=1;i<uwsgi.numproc+1;i++) {
+				for(i=1;i<uwsgi.numproc+1;i++)
 					tmp_counter += uwsgi.workers[i].requests;
-				}
 				uwsgi.workers[0].requests = tmp_counter;
 			}
+		
+			if (uwsgi.idle > 0 && !uwsgi.cheap) {
+				uwsgi.current_time = time(NULL);
+				if (!last_request_timecheck) last_request_timecheck = uwsgi.current_time;
+				if (last_request_count != uwsgi.workers[0].requests) {
+					last_request_timecheck = uwsgi.current_time;
+					last_request_count = uwsgi.workers[0].requests;
+				}
+				else if (uwsgi.current_time - last_request_timecheck > uwsgi.idle) {
+					uwsgi_log("workers have been inactive for more than %d seconds\n", uwsgi.idle);
+					uwsgi.cheap = 1;
+					master_has_children = 0;
+					if (uwsgi.die_on_idle) {
+						if (uwsgi.has_emperor) {
+							char byte = 22;
+							if (write(uwsgi.emperor_fd, &byte, 1) != 1) {
+								uwsgi_error("write()");
+								kill_them_all(0);	
+							}
+						}
+						else {
+							kill_them_all(0);	
+						}
+						continue;
+					}
+					for(i=1;i<=uwsgi.numproc;i++) {
+                               			if (uwsgi.workers[i].pid == 0) continue;
+                               			kill(uwsgi.workers[i].pid, SIGKILL);
+                               			if (waitpid(uwsgi.workers[i].pid, &waitpid_status, 0) < 0) {
+                                       			uwsgi_error("waitpid()");
+                               			}
+					}
+					uwsgi_add_sockets_to_queue(uwsgi.master_queue);
+                			uwsgi_log("cheap mode enabled: waiting for socket connection...\n");
+					last_request_timecheck = 0;
+					continue;	
+				}
+			}
 
 			// remove expired cache items TODO use rb_tree timeouts
 			if (uwsgi.cache_max_items > 0) {
 				for(i=0;i< (int)uwsgi.cache_max_items;i++) {
 					uwsgi_wlock(uwsgi.cache_lock);
 					if (uwsgi.cache_items[i].expires) {
-						if (uwsgi.cache_items[i].expires < (uint64_t) current_time) {
+						if (uwsgi.cache_items[i].expires < (uint64_t) uwsgi.current_time) {
 							uwsgi_cache_del(uwsgi.cache_items[i].key, uwsgi.cache_items[i].keysize);
 						}
 					}
@@ -894,7 +1100,7 @@ void master_loop(char **argv, char **environ) {
 			for (i = 1; i <= uwsgi.numproc; i++) {
 				/* first check for harakiri */
 				if (uwsgi.workers[i].harakiri > 0) {
-					if (uwsgi.workers[i].harakiri < (time_t) current_time) {
+					if (uwsgi.workers[i].harakiri < (time_t) uwsgi.current_time) {
 						/* first try to invoke the harakiri() custom handler */
 						/* TODO */
 						/* then brutally kill the worker */
@@ -948,37 +1154,15 @@ void master_loop(char **argv, char **environ) {
 
 #ifdef UWSGI_UDP
 			// check for cluster nodes
-			for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-				struct uwsgi_cluster_node *ucn = &uwsgi.shared->nodes[i];
-
-				if (ucn->name[0] != 0 && ucn->type == CLUSTER_NODE_STATIC && ucn->status == UWSGI_NODE_FAILED) {
-					// should i retry ?
-					if (master_cycles % ucn->errors == 0) {
-						if (!uwsgi_ping_node(i, uwsgi.wsgi_req)) {
-							ucn->status = UWSGI_NODE_OK;
-							uwsgi_log( "re-enabled cluster node %d/%s\n", i, ucn->name);
-						}
-						else {
-							ucn->errors++;
-						}
-					}
-				}
-				else if (ucn->name[0] != 0 && ucn->type == CLUSTER_NODE_DYNAMIC) {
-					// if the last_seen attr is higher than 30 secs ago, mark the node as dead
-					if ( (current_time - ucn->last_seen) > 30) {
-						uwsgi_log_verbose("no presence announce in the last 30 seconds by node %s, i assume it is dead.\n", ucn->name);
-						ucn->name[0] = 0 ;
-					}
-				}
-			}
+			master_check_cluster_nodes();
 
 			// reannounce myself every 10 cycles
-			if (uwsgi.cluster && uwsgi.cluster_fd >= 0 && !uwsgi.cluster_nodes && (master_cycles % 10) == 0) {
+			if (uwsgi.cluster && uwsgi.cluster_fd >= 0 && !uwsgi.cluster_nodes && (uwsgi.master_cycles % 10) == 0) {
 				uwsgi_cluster_add_me();
 			}
 
 			// resubscribe every 10 cycles
-			if (uwsgi.subscriptions_cnt > 0 && ((master_cycles % 10) == 0 || master_cycles == 1)) {
+			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]);
 				}
@@ -986,13 +1170,13 @@ void master_loop(char **argv, char **environ) {
 
 #endif
 
-			if (uwsgi.cache_store && uwsgi.cache_filesize && uwsgi.cache_store_sync && ((master_cycles % uwsgi.cache_store_sync) == 0)) {
+			if (uwsgi.cache_store && uwsgi.cache_filesize && uwsgi.cache_store_sync && ((uwsgi.master_cycles % uwsgi.cache_store_sync) == 0)) {
 				if (msync(uwsgi.cache_items, uwsgi.cache_filesize, MS_ASYNC)) {
                         		uwsgi_error("msync()");
                 		}
 			}
 
-			if (uwsgi.queue_store && uwsgi.queue_filesize && uwsgi.queue_store_sync && ((master_cycles % uwsgi.queue_store_sync) == 0)) {
+			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)) {
                         		uwsgi_error("msync()");
                 		}
@@ -1021,6 +1205,9 @@ void master_loop(char **argv, char **environ) {
 			continue;
 
 		}
+		// reload gateways and daemons only on normal workflow
+		if (!uwsgi.to_heaven && !uwsgi.to_hell) {
+
 #ifdef UWSGI_SPOOLER
 		/* reload the spooler */
 		if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
@@ -1032,8 +1219,6 @@ void master_loop(char **argv, char **environ) {
 		}
 #endif
 
-		// reload gateways and daemons only on normal workflow
-		if (!uwsgi.to_heaven && !uwsgi.to_hell) {
 		/* reload the gateways */
 		// TODO reload_gateway(diedpid);
 		pid_found = 0;
@@ -1059,6 +1244,7 @@ void master_loop(char **argv, char **environ) {
                 }
 
 		if (pid_found) continue;
+
 		}
 
 		/* What happens here ?
@@ -1107,9 +1293,16 @@ void master_loop(char **argv, char **environ) {
 		}
 		gettimeofday(&last_respawn, NULL);
 		if (last_respawn.tv_sec == uwsgi.respawn_delta) {
-			uwsgi_log( "worker respawning too fast !!! i have to sleep a bit...\n");
-			/* TODO, user configurable fork throttler */
-			sleep(2);
+			last_respawn_rate++;
+			if (last_respawn_rate > uwsgi.numproc) {
+				uwsgi_log( "worker respawning too fast !!! i have to sleep a bit...\n");
+				/* TODO, user configurable fork throttler */
+				sleep(2);
+				last_respawn_rate = 0;
+			}
+		}
+		else {
+			last_respawn_rate = 0;
 		}
 		gettimeofday(&last_respawn, NULL);
 		uwsgi.respawn_delta = last_respawn.tv_sec;
@@ -1121,27 +1314,9 @@ void master_loop(char **argv, char **environ) {
 			continue;
 		}
 		*/
-		pid = fork();
-		if (pid == 0) {
-			// fix the communication pipe
-			close(uwsgi.shared->worker_signal_pipe[0]);
-			uwsgi.mypid = getpid();
-			uwsgi.workers[uwsgi.mywid].pid = uwsgi.mypid;
-			uwsgi.workers[uwsgi.mywid].harakiri = 0;
-			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 = current_time;
-			uwsgi.workers[uwsgi.mywid].manage_next_request = 1;
-			break;
-		}
-		else if (pid < 1) {
-			uwsgi_error("fork()");
-		}
-		else {
-			uwsgi_log( "Respawned uWSGI worker %d (new pid: %d)\n", uwsgi.mywid, (int) pid);
-		}
+		if (uwsgi_respawn_worker(uwsgi.mywid)) return;
 
 	}
 }
+
 }

master_utils.c

@@ -0,0 +1,259 @@
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+void master_check_cluster_nodes() {
+
+	int i;
+
+	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
+		struct uwsgi_cluster_node *ucn = &uwsgi.shared->nodes[i];
+
+		if (ucn->name[0] != 0 && ucn->type == CLUSTER_NODE_STATIC && ucn->status == UWSGI_NODE_FAILED) {
+			// should i retry ?
+			if (uwsgi.master_cycles % ucn->errors == 0) {
+				if (!uwsgi_ping_node(i, uwsgi.wsgi_req)) {
+					ucn->status = UWSGI_NODE_OK;
+					uwsgi_log("re-enabled cluster node %d/%s\n", i, ucn->name);
+				}
+				else {
+					ucn->errors++;
+				}
+			}
+		}
+		else if (ucn->name[0] != 0 && ucn->type == CLUSTER_NODE_DYNAMIC) {
+			// if the last_seen attr is higher than 30 secs ago, mark the node as dead
+			if ((uwsgi.current_time - ucn->last_seen) > 30) {
+				uwsgi_log_verbose("no presence announce in the last 30 seconds by node %s, i assume it is dead.\n", ucn->name);
+				ucn->name[0] = 0;
+			}
+		}
+	}
+}
+
+
+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();
+
+	if (pid == 0) {
+		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;
+		uwsgi.workers[uwsgi.mywid].respawn_count++;
+		uwsgi.workers[uwsgi.mywid].last_spawn = uwsgi.current_time;
+		uwsgi.workers[uwsgi.mywid].manage_next_request = 1;
+
+		// 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.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);
+                			}
+        			}
+			}
+		}
+		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);
+		}
+		else {
+			uwsgi_log("spawned uWSGI worker %d (pid: %d, cores: %d)\n", wid, pid, uwsgi.cores);
+		}
+	}
+
+	return 0;
+}
+
+
+void uwsgi_manage_signal_cron(time_t now) {
+
+	struct tm *uwsgi_cron_delta;
+	int i;
+
+	uwsgi.current_time = now;
+	uwsgi_cron_delta = localtime(&uwsgi.current_time);
+
+	if (uwsgi_cron_delta) {
+
+		// fix month
+		uwsgi_cron_delta->tm_mon++;
+
+		uwsgi_lock(uwsgi.cron_table_lock);
+		for (i = 0; i < ushared->cron_cnt; i++) {
+
+			struct uwsgi_cron *ucron = &ushared->cron[i];
+			int uc_minute, uc_hour, uc_day, uc_month, uc_week;
+
+			uc_minute = ucron->minute;
+			uc_hour = ucron->hour;
+			uc_day = ucron->day;
+			uc_month = ucron->month;
+			uc_week = ucron->week;
+
+			if (ucron->minute == -1)
+				uc_minute = uwsgi_cron_delta->tm_min;
+			if (ucron->hour == -1)
+				uc_hour = uwsgi_cron_delta->tm_hour;
+			if (ucron->month == -1)
+				uc_month = uwsgi_cron_delta->tm_mon;
+
+			// mday and wday are ORed
+			if (ucron->day == -1 && ucron->week == -1) {
+				if (ucron->day == -1)
+					uc_day = uwsgi_cron_delta->tm_mday;
+				if (ucron->week == -1)
+					uc_week = uwsgi_cron_delta->tm_wday;
+			}
+			else if (ucron->day == -1) {
+				ucron->day = uwsgi_cron_delta->tm_mday;
+			}
+			else if (ucron->week == -1) {
+				ucron->week = uwsgi_cron_delta->tm_wday;
+			}
+			else {
+				if (ucron->day == uwsgi_cron_delta->tm_mday) {
+					ucron->week = uwsgi_cron_delta->tm_wday;
+				}
+				else if (ucron->week == uwsgi_cron_delta->tm_wday) {
+					ucron->day = uwsgi_cron_delta->tm_mday;
+				}
+			}
+
+			if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
+
+
+				// date match, signal it ?
+				if (uwsgi.current_time - ucron->last_job > 60) {
+					uwsgi_route_signal(ucron->sig);
+					ucron->last_job = uwsgi.current_time;
+				}
+			}
+
+		}
+		uwsgi_unlock(uwsgi.cron_table_lock);
+	}
+	else {
+		uwsgi_error("localtime()");
+	}
+
+}
+
+void uwsgi_manage_command_cron(time_t now) {
+
+	struct tm *uwsgi_cron_delta;
+
+	struct uwsgi_cron *current_cron = uwsgi.crons;
+	int uc_minute, uc_hour, uc_day, uc_month, uc_week;
+
+	uwsgi.current_time = now;
+	uwsgi_cron_delta = localtime(&uwsgi.current_time);
+
+
+	if (!uwsgi_cron_delta) {
+		uwsgi_error("localtime()");
+		return;
+	}
+
+	while (current_cron) {
+
+
+		uc_minute = current_cron->minute;
+		uc_hour = current_cron->hour;
+		uc_day = current_cron->day;
+		uc_month = current_cron->month;
+		uc_week = current_cron->week;
+
+		if (current_cron->minute == -1)
+			uc_minute = uwsgi_cron_delta->tm_min;
+		if (current_cron->hour == -1)
+			uc_hour = uwsgi_cron_delta->tm_hour;
+		if (current_cron->month == -1)
+			uc_month = uwsgi_cron_delta->tm_mon;
+
+		// mday and wday are ORed
+		if (current_cron->day == -1 && current_cron->week == -1) {
+			if (current_cron->day == -1)
+				uc_day = uwsgi_cron_delta->tm_mday;
+			if (current_cron->week == -1)
+				uc_week = uwsgi_cron_delta->tm_wday;
+		}
+		else if (current_cron->day == -1) {
+			current_cron->day = uwsgi_cron_delta->tm_mday;
+		}
+		else if (current_cron->week == -1) {
+			current_cron->week = uwsgi_cron_delta->tm_wday;
+		}
+		else {
+			if (current_cron->day == uwsgi_cron_delta->tm_mday) {
+				current_cron->week = uwsgi_cron_delta->tm_wday;
+			}
+			else if (current_cron->week == uwsgi_cron_delta->tm_wday) {
+				current_cron->day = uwsgi_cron_delta->tm_mday;
+			}
+		}
+
+		if (uwsgi_cron_delta->tm_min == uc_minute && uwsgi_cron_delta->tm_hour == uc_hour && uwsgi_cron_delta->tm_mon == uc_month && uwsgi_cron_delta->tm_mday == uc_day && uwsgi_cron_delta->tm_wday == uc_week) {
+
+
+			// date match, run command ?
+			if (uwsgi.current_time - current_cron->last_job > 60) {
+				//call command
+				if (current_cron->command) {
+					if (uwsgi_run_command(current_cron->command) >=0) {
+						uwsgi_log_verbose("[uWSGI-cron] running %s\n", current_cron->command);
+					}
+				}
+				current_cron->last_job = uwsgi.current_time;
+			}
+		}
+
+
+
+		current_cron = current_cron->next;
+	}
+
+
+}

multiapp.py

@@ -1,14 +1,9 @@
 import werkzeug
-
-def web3_app(environ):
-    status = b'200 OK'
-    headers = [(b'Content-type', b'text/plain')]
-    body = [b'I am a Web3 app\n']
-    return body, status, headers
+import uwsgi
 
 def zero_app(e,s):
     s('200 OK', [ ('Content-Type', 'text/plain') ])
-    return ""
+    return "0"
 
 def not_found(e,s):
     s('404 Not Found', [ ('Content-Type', 'text/plain') ])
@@ -24,4 +19,4 @@ def internal_server_error(e, s):
     s('500 Internal Server Error', [ ('Content-Type', 'text/plain') ])
     return ""
 
-applications = {'':web3_app, '/wsgi':wsgi_app, '/test':werkzeug.test_app, '/zero':zero_app, '/notfound':not_found, '/ise':internal_server_error}
+uwsgi.applications = {'/wsgi':wsgi_app, '/test':werkzeug.test_app, '/zero':zero_app, '/notfound':not_found, '/ise':internal_server_error}

myadmin.py

@@ -2,6 +2,16 @@ import uwsgi
 import struct
 import sys
 
+print sys.argv
+if len(sys.argv) == 3:
+	chunks = uwsgi.send_message(sys.argv[1], 10, int(sys.argv[2]), '')
 
-print uwsgi.send_uwsgi_message(sys.argv[1], int(sys.argv[2]), 10, int(sys.argv[3]), struct.pack("i", int(sys.argv[4])))
+	pkt = ''
+
+	for chunk in chunks:
+    		pkt += chunk
+
+	print "%d = %d" % (int(sys.argv[2]), struct.unpack("I", pkt)[0])
+elif len(sys.argv) == 4:
+	uwsgi.send_message(sys.argv[1], 10, int(sys.argv[2]), struct.pack("I", int(sys.argv[3])))
 

notify.c

@@ -40,7 +40,7 @@ void uwsgi_systemd_notify_ready(void) {
 
 void uwsgi_systemd_init(char *systemd_socket) {
 
-	struct sockaddr_un *sun;
+	struct sockaddr_un *sd_sun;
 	struct msghdr *msghdr;
 
 	uwsgi.notification_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
@@ -49,11 +49,11 @@ void uwsgi_systemd_init(char *systemd_socket) {
 		return;
 	}
 
-	sun = uwsgi_malloc(sizeof(struct sockaddr_un));
-	memset(sun, 0, sizeof(struct sockaddr_un));
-	sun->sun_family = AF_UNIX;
-	strncpy(sun->sun_path, systemd_socket, sizeof(sun->sun_path));
-	if (sun->sun_path[0] == '@') sun->sun_path[0] = 0;
+	sd_sun = uwsgi_malloc(sizeof(struct sockaddr_un));
+	memset(sd_sun, 0, sizeof(struct sockaddr_un));
+	sd_sun->sun_family = AF_UNIX;
+	strncpy(sd_sun->sun_path, systemd_socket, sizeof(sd_sun->sun_path));
+	if (sd_sun->sun_path[0] == '@') sd_sun->sun_path[0] = 0;
 
 	msghdr = uwsgi_malloc(sizeof(struct msghdr));
 	memset(msghdr, 0, sizeof(struct msghdr));
@@ -61,7 +61,7 @@ void uwsgi_systemd_init(char *systemd_socket) {
 	msghdr->msg_iov = uwsgi_malloc(sizeof(struct iovec)*3);
 	memset(msghdr->msg_iov, 0, sizeof(struct iovec)*3);
 
-	msghdr->msg_name = sun;
+	msghdr->msg_name = sd_sun;
 	msghdr->msg_namelen = sizeof(struct sockaddr_un);
 
 	uwsgi.notification_object = msghdr;

plugins/admin/admin_plugin.c

@@ -1,28 +1,58 @@
+#include "../../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
 /* uwsgi ADMIN|10 */
 int uwsgi_request_admin(struct wsgi_request *wsgi_req) {
+
         uint32_t opt_value = 0;
-        int i;
+        ssize_t len;
 
-        if (wsgi_req->uh.pktsize >= 4) {
+	if (wsgi_req->uh.pktsize != 0 && wsgi_req->uh.pktsize != 4)
+		return UWSGI_OK;
+
+	// write request
+	if (wsgi_req->uh.pktsize == 4) {
                 memcpy(&opt_value, wsgi_req->buffer, 4);
-                // TODO: check endianess ?
-        }
-
-        uwsgi_log( "setting internal option %d to %d\n", wsgi_req->uh.modifier2, opt_value);
-        uwsgi.shared->options[wsgi_req->uh.modifier2] = opt_value;
-
-        // ACK
-        wsgi_req->uh.modifier1 = 255;
-        wsgi_req->uh.pktsize = 0;
-        wsgi_req->uh.modifier2 = 1;
-
-        i = write(wsgi_req->poll.fd, wsgi_req, 4);
-        if (i != 4) {
-                uwsgi_error("write()");
-        }
+        	uwsgi_log( "setting internal option %d to %d\n", wsgi_req->uh.modifier2, opt_value);
+        	uwsgi.shared->options[wsgi_req->uh.modifier2] = opt_value;
 
+        	// ACK
+        	wsgi_req->uh.modifier1 = 255;
+        	wsgi_req->uh.pktsize = 0;
+        	wsgi_req->uh.modifier2 = 1;
+        	len = write(wsgi_req->poll.fd, wsgi_req, 4);
+        	if (len != 4) {
+                	uwsgi_error("write()");
+        	}
+	}
+	// get request
+	else {
+		uwsgi_log( "internal option %d = %d\n", wsgi_req->uh.modifier2, uwsgi.shared->options[wsgi_req->uh.modifier2]);
 
+		wsgi_req->uh.modifier1 = 10;
+		wsgi_req->uh.pktsize = 4;
+		len = write(wsgi_req->poll.fd, wsgi_req, 4);
+                if (len != 4) {
+                        uwsgi_error("write()");
+			return UWSGI_OK;
+                }
+		len = write(wsgi_req->poll.fd, (char *) &uwsgi.shared->options[wsgi_req->uh.modifier2], 4);
+                if (len != 4) {
+                        uwsgi_error("write()");
+		}
+		
+	}
 
         return UWSGI_OK;
 }
 
+
+struct uwsgi_plugin admin_plugin = {
+
+        .name = "admin",
+        .modifier1 = 10,
+        .request = uwsgi_request_admin,
+
+};
+

plugins/admin/uwsgiplugin.py

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

plugins/cache/cache.c

@@ -9,6 +9,9 @@ void cache_command(char *key, uint16_t keylen, char *val, uint16_t vallen, void
                 if (!uwsgi_strncmp(key, keylen, "key", 3)) {
                         val = uwsgi_cache_get(val, vallen, &tmp_vallen);
                         if (val && tmp_vallen > 0) {
+#ifdef UWSGI_DEBUG
+				uwsgi_log("cache value size: %llu\n", tmp_vallen);
+#endif
                                 wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, val, tmp_vallen);
                         }
 

plugins/cplusplus/base.cc

@@ -0,0 +1,63 @@
+#include "../../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+class FakeClass {
+
+	public:
+		char *foobar;
+		uint16_t foobar_len;
+		void hello_world(struct wsgi_request *);
+
+};
+
+void FakeClass::hello_world(struct wsgi_request *wsgi_req) {
+
+	wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, (char *) "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n", 44);
+	wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, foobar, foobar_len);
+}
+
+extern "C" int uwsgi_cplusplus_init(){
+        uwsgi_log("Initializing example c++ plugin\n");
+        return 0;
+}
+
+extern "C" int uwsgi_cplusplus_request(struct wsgi_request *wsgi_req) {
+
+	FakeClass *fc;
+
+	// empty request ?
+	if (!wsgi_req->uh.pktsize) {
+                uwsgi_log( "Invalid request. skip.\n");
+		goto clear;
+        }
+
+	// get uwsgi variables
+        if (uwsgi_parse_vars(wsgi_req)) {
+                uwsgi_log("Invalid request. skip.\n");
+                goto clear;
+        }
+
+	fc = new FakeClass();
+	// get PATH_INFO
+        fc->foobar = uwsgi_get_var(wsgi_req, (char *) "PATH_INFO", &fc->foobar_len);
+
+	if (fc->foobar) {
+		// send output
+		fc->hello_world(wsgi_req);
+	}
+
+	delete fc;
+
+clear:
+        return UWSGI_OK;
+}
+
+
+extern "C" void uwsgi_cplusplus_after_request(struct wsgi_request *wsgi_req) {
+        uwsgi_log("logging c++ request\n");
+}
+
+
+
+

plugins/cplusplus/plugin.c

@@ -0,0 +1,17 @@
+#include "../../uwsgi.h"
+
+
+int uwsgi_cplusplus_init(void);
+int uwsgi_cplusplus_request(struct wsgi_request *);
+void uwsgi_cplusplus_after_request(struct wsgi_request *);
+
+struct uwsgi_plugin cplusplus_plugin = {
+
+        .name = "cplusplus",
+        .modifier1 = 250,
+        .init = uwsgi_cplusplus_init,
+        .request = uwsgi_cplusplus_request,
+        .after_request = uwsgi_cplusplus_after_request,
+
+};
+

plugins/cplusplus/uwsgiplugin.py

@@ -0,0 +1,6 @@
+NAME='cplusplus'
+
+CFLAGS = []
+LDFLAGS = []
+LIBS = ['-lstdc++']
+GCC_LIST = ['base.cc', 'plugin']

plugins/echo/echo_plugin.c

@@ -5,7 +5,7 @@ extern struct uwsgi_server uwsgi;
 
 int uwsgi_echo_request(struct wsgi_request *wsgi_req) {
 
-	wsgi_req->response_size = wsgi_req->socket_proto_write(wsgi_req, wsgi_req->buffer, wsgi_req->uh.pktsize);
+	wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, wsgi_req->buffer, wsgi_req->uh.pktsize);
 	
 	return 0;
 }

plugins/example/example_plugin.c

@@ -2,21 +2,33 @@
 
 extern struct uwsgi_server uwsgi;
 
-int uwsgi_init(char *args){
-	uwsgi_log("i am the example plugin initialization function with arg: %s\n", args);
+int uwsgi_example_init(){
+	uwsgi_log("i am the example plugin initialization function\n");
 	return 0;
 }
 
-int uwsgi_request(struct wsgi_request *wsgi_req) {
+int uwsgi_example_request(struct wsgi_request *wsgi_req) {
 
 	char *http = "HTTP/1.1 200 Ok\r\nContent-type: text/html\r\n\r\n<h1>Hello World</h1>";
 
-	wsgi_req->response_size += wsgi_req->socket_proto_write(wsgi_req, http, strlen(http));
+	wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, http, strlen(http));
 
 	return 0;
 }
 
 
-void uwsgi_after_request(struct wsgi_request *wsgi_req) {
+void uwsgi_example_after_request(struct wsgi_request *wsgi_req) {
 	uwsgi_log("i am the example plugin after request function\n");
 }
+
+
+struct uwsgi_plugin example_plugin = {
+
+        .name = "example",
+        .modifier1 = 250,
+        .init = uwsgi_example_init,
+        .request = uwsgi_example_request,
+        .after_request = uwsgi_example_after_request,
+
+};
+

plugins/example/uwsgiplugin.py

@@ -1,3 +1,6 @@
 NAME='example'
-CFLAGS = ''
-LDFLAGS = ''
+
+CFLAGS = []
+LDFLAGS = []
+LIBS = []
+GCC_LIST = ['example_plugin']

plugins/fastrouter/fastrouter.c

@@ -18,6 +18,7 @@
 #define LONG_ARGS_FASTROUTER_USE_BASE			150004
 #define LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER	150005
 #define LONG_ARGS_FASTROUTER_TIMEOUT			150006
+#define LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT		150007
 
 #define FASTROUTER_STATUS_FREE 0
 #define FASTROUTER_STATUS_CONNECTING 1
@@ -28,25 +29,62 @@
 #define add_timeout(x) uwsgi_add_rb_timer(ufr.timeouts, time(NULL)+ufr.socket_timeout, x)
 #define del_timeout(x) rb_erase(&x->timeout->rbt, ufr.timeouts); free(x->timeout);
 
+struct uwsgi_fastrouter_socket {
+	char *name;
+	int fd;
+	struct uwsgi_fastrouter_socket *next;
+};
+
 struct uwsgi_fastrouter {
-	char *socket_name;
-	int use_cache;
-	int nevents;
 
-	char *pattern;
-	int pattern_len;
+        struct uwsgi_fastrouter_socket *sockets;
 
-	char *base;
-	int base_len;
+        int use_cache;
+        int nevents;
 
-	char *subscription_server;
-	struct uwsgi_dict *subscription_dict;
+        int subscription_slot;
 
-	int socket_timeout;
+        char *pattern;
+        int pattern_len;
 
-	struct rb_root *timeouts;
+        char *base;
+        int base_len;
+
+        char *subscription_server;
+        struct uwsgi_dict *subscription_dict;
+
+        int socket_timeout;
+
+        struct rb_root *timeouts;
 } ufr;
 
+
+static struct uwsgi_fastrouter_socket *uwsgi_fastrouter_new_socket(char *name) {
+
+        struct uwsgi_fastrouter_socket *uwsgi_sock = ufr.sockets, *old_uwsgi_sock;
+
+        if (!uwsgi_sock) {
+                ufr.sockets = uwsgi_malloc(sizeof(struct uwsgi_fastrouter_socket));
+                uwsgi_sock = ufr.sockets;
+        }
+        else {
+                while(uwsgi_sock) {
+                        old_uwsgi_sock = uwsgi_sock;
+                        uwsgi_sock = uwsgi_sock->next;
+                }
+
+                uwsgi_sock = uwsgi_malloc(sizeof(struct uwsgi_fastrouter_socket));
+                old_uwsgi_sock->next = uwsgi_sock;
+        }
+
+        memset(uwsgi_sock, 0, sizeof(struct uwsgi_fastrouter_socket));
+        uwsgi_sock->name = name;
+
+        return uwsgi_sock;
+}
+
+
+
 struct option fastrouter_options[] = {
 	{"fastrouter", required_argument, 0, LONG_ARGS_FASTROUTER},
 	{"fastrouter-use-cache", no_argument, &ufr.use_cache, 1},
@@ -54,6 +92,7 @@ struct option fastrouter_options[] = {
 	{"fastrouter-use-base", required_argument, 0, LONG_ARGS_FASTROUTER_USE_BASE},
 	{"fastrouter-events", required_argument, 0, LONG_ARGS_FASTROUTER_EVENTS},
 	{"fastrouter-subscription-server", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER},
+	{"fastrouter-subscription-slot", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT},
 	{"fastrouter-timeout", required_argument, 0, LONG_ARGS_FASTROUTER_TIMEOUT},
 	{0, 0, 0, 0},	
 };
@@ -72,6 +111,10 @@ void fastrouter_manage_subscription(char *key, uint16_t keylen, char *val, uint1
 		usr->address = val;
 		usr->address_len = vallen;
 	}
+
+	else if (!uwsgi_strncmp("modifier1", 9, key, keylen)) {
+		usr->modifier1 = uwsgi_str_num(val, vallen);
+	}
 }
 
 struct fastrouter_session {
@@ -87,6 +130,8 @@ struct fastrouter_session {
 	char *hostname;
 	uint16_t hostname_len;
 
+	int has_key;
+
 	char *instance_address;
 	uint64_t instance_address_len;
 
@@ -95,6 +140,8 @@ struct fastrouter_session {
 
 	struct uwsgi_rb_timer *timeout;
 	int instance_failed;
+
+	uint8_t modifier1;
 };
 
 static void close_session(struct fastrouter_session **fr_table, struct fastrouter_session *fr_session) {
@@ -148,7 +195,14 @@ void fr_get_hostname(char *key, uint16_t keylen, char *val, uint16_t vallen, voi
 		return;
 	}
 
-	if (!uwsgi_strncmp("HTTP_HOST", 9, key, keylen)) {
+	if (!uwsgi_strncmp("HTTP_HOST", 9, key, keylen) && !fr_session->has_key) {
+		fr_session->hostname = val;
+		fr_session->hostname_len = vallen;
+		return;
+	}
+
+	if (!uwsgi_strncmp("UWSGI_FASTROUTER_KEY", 20, key, keylen)) {
+		fr_session->has_key = 1;
 		fr_session->hostname = val;
 		fr_session->hostname_len = vallen;
 		return;
@@ -163,7 +217,6 @@ struct fastrouter_session *alloc_fr_session() {
 void fastrouter_loop() {
 
 	int fr_queue;
-	int fr_server = -1;
 	int nevents;
 	int interesting_fd;
 	int new_connection;
@@ -210,37 +263,43 @@ void fastrouter_loop() {
 		fr_table[i] = NULL;
 	}
 
-	if (ufr.socket_name[0] == '=') {
-		int shared_socket = atoi(ufr.socket_name+1);
-		if (shared_socket >= 0 && shared_socket < uwsgi.shared_sockets_cnt) {
-			if (uwsgi.shared_sockets[shared_socket].name) {
-				fr_server = uwsgi.shared_sockets[shared_socket].fd;
-			}	
-			else {
-				uwsgi_log("unable to use shared socket %d\n", shared_socket);
+	fr_queue = event_queue_init();
+
+	struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+
+	while(ufr_sock) {
+		if (ufr_sock->name[0] == '=') {
+			int shared_socket = atoi(ufr_sock->name+1);
+			if (shared_socket >= 0) {
+				ufr_sock->fd = uwsgi_get_shared_socket_fd_by_num(shared_socket);
+				if (ufr_sock->fd == -1) {
+					uwsgi_log("unable to use shared socket %d\n", shared_socket);
+				}
 			}
 		}
-	}
-	else {
-		tcp_port = strchr(ufr.socket_name, ':');
-		if (tcp_port) {
-			fr_server = bind_to_tcp(ufr.socket_name, uwsgi.listen_queue, tcp_port);
-		}
 		else {
-			fr_server = bind_to_unix(ufr.socket_name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+			tcp_port = strchr(ufr_sock->name, ':');
+			if (tcp_port) {
+				ufr_sock->fd = bind_to_tcp(ufr_sock->name, uwsgi.listen_queue, tcp_port);
+			}
+			else {
+				ufr_sock->fd = bind_to_unix(ufr_sock->name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+			}
 		}
+
+		event_queue_add_fd_read(fr_queue, ufr_sock->fd);
+		ufr_sock = ufr_sock->next;
 	}
 
-	fr_queue = event_queue_init();
 
 	events = event_queue_alloc(ufr.nevents);
 
-	event_queue_add_fd_read(fr_queue, fr_server);
 
 	if (ufr.subscription_server) {
 		ufr_subserver = bind_to_udp(ufr.subscription_server, 0, 0);
 		event_queue_add_fd_read(fr_queue, ufr_subserver);
-		ufr.subscription_dict = uwsgi_dict_create(30, 0);
+		if (!ufr.subscription_slot) ufr.subscription_slot = 30;
+		ufr.subscription_dict = uwsgi_dict_create(ufr.subscription_slot, 0);
 	}
 
 	if (ufr.pattern) {
@@ -276,27 +335,39 @@ void fastrouter_loop() {
 			interesting_fd = event_queue_interesting_fd(events, i);
 
 
-			if (interesting_fd == fr_server) {
-				new_connection = accept(fr_server, (struct sockaddr *) &fr_addr, &fr_addr_len);
-				if (new_connection < 0) {
-					continue;
-				}
+			int taken = 0;
+			struct uwsgi_fastrouter_socket *uwsgi_sock = ufr.sockets;
+			while(uwsgi_sock) {
+				if (interesting_fd == uwsgi_sock->fd) {
+					new_connection = accept(interesting_fd, (struct sockaddr *) &fr_addr, &fr_addr_len);
+					if (new_connection < 0) {
+						continue;
+					}
 
-				fr_table[new_connection] = alloc_fr_session();
-				fr_table[new_connection]->fd = new_connection;
-				fr_table[new_connection]->instance_fd = -1; 
-				fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
-				fr_table[new_connection]->h_pos = 0;
-				fr_table[new_connection]->pos = 0;
-				fr_table[new_connection]->instance_failed = 0;
-				fr_table[new_connection]->instance_address_len = 0;
+					fr_table[new_connection] = alloc_fr_session();
+					fr_table[new_connection]->fd = new_connection;
+					fr_table[new_connection]->instance_fd = -1; 
+					fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
+					fr_table[new_connection]->h_pos = 0;
+					fr_table[new_connection]->pos = 0;
+					fr_table[new_connection]->instance_failed = 0;
+					fr_table[new_connection]->instance_address_len = 0;
 		
-				fr_table[new_connection]->timeout = add_timeout(fr_table[new_connection]);
+					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(fr_queue, new_connection);
+					taken = 1;
+					break;
+				}
 				
+				uwsgi_sock = uwsgi_sock->next;
 			}	
-			else if (interesting_fd == ufr_subserver) {
+
+			if (taken) {
+				continue;
+			}
+
+			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);
@@ -304,7 +375,7 @@ void fastrouter_loop() {
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
-					uwsgi_add_subscriber(ufr.subscription_dict, usr.key, usr.keylen, usr.address, usr.address_len);
+					uwsgi_add_subscriber(ufr.subscription_dict, &usr);
 				}
 			}
 			else {
@@ -358,7 +429,9 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
-							//uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
+#ifdef UWSGI_DEBUG
+							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);
 							}
@@ -374,6 +447,7 @@ void fastrouter_loop() {
 								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;
+									fr_session->modifier1 = fr_session->un->modifier1;
 								}
 							}
 							else if (ufr.base) {
@@ -431,13 +505,19 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
+							fr_session->uh.modifier1 = fr_session->modifier1;
+
 							iov[0].iov_base = &fr_session->uh;
 							iov[0].iov_len = 4;
 							iov[1].iov_base = fr_session->buffer;
 							iov[1].iov_len = fr_session->uh.pktsize;
 
+							// increment node requests counter
+							if (fr_session->un)
+								fr_session->un->requests++;
+
 							// fd passing: PERFORMANCE EXTREME BOOST !!!
-							if (fr_session->pass_fd) {
+							if (fr_session->pass_fd && !uwsgi.no_fd_passing) {
 								msg.msg_name    = NULL;
                 						msg.msg_namelen = 0;
                 						msg.msg_iov     = iov;
@@ -491,6 +571,10 @@ void fastrouter_loop() {
 								close_session(fr_table, fr_session);
                                                         	break;
 							}
+
+							// update transfer statistics
+							if (fr_session->un)
+								fr_session->un->transferred += len;
 						}
 						// body from client
 						else if (interesting_fd == fr_session->fd) {
@@ -532,7 +616,7 @@ void fastrouter_loop() {
 
 int fastrouter_init() {
 
-	if (ufr.socket_name) {
+	if (ufr.sockets) {
 
 		if (ufr.use_cache && !uwsgi.cache_max_items) {
 			uwsgi_log("you need to create a uwsgi cache to use the fastrouter (add --cache <n>)\n");
@@ -554,7 +638,7 @@ int fastrouter_opt(int i, char *optarg) {
 
 	switch(i) {
 		case LONG_ARGS_FASTROUTER:
-			ufr.socket_name = optarg;
+			uwsgi_fastrouter_new_socket(generate_socket_name(optarg));
 			return 1;
 		case LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER:
 			ufr.subscription_server = optarg;
@@ -575,6 +659,9 @@ int fastrouter_opt(int i, char *optarg) {
 		case LONG_ARGS_FASTROUTER_TIMEOUT:
 			ufr.socket_timeout = atoi(optarg);
 			return -1;
+		case LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT:
+			ufr.subscription_slot = atoi(optarg);
+			return 1;
 	}
 	return 0;
 }

plugins/http/http.c

@@ -542,7 +542,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.key, usr.keylen, usr.address, usr.address_len);
+					uwsgi_add_subscriber(uhttp.subscription_dict, &usr);
 				}
 			}
 			else {
@@ -710,7 +710,7 @@ void http_loop() {
 
 #ifndef __sun__
 							// fd passing: PERFORMANCE EXTREME BOOST !!!
-							if (uhttp_session->pass_fd && !uhttp_session->remains) {
+							if (uhttp_session->pass_fd && !uhttp_session->remains && !uwsgi.no_fd_passing) {
 								msg.msg_name    = NULL;
                 						msg.msg_namelen = 0;
                 						msg.msg_iov     = uhttp_session->iov;
@@ -869,9 +869,7 @@ int http_init() {
 		if (!uhttp.nevents) uhttp.nevents = 64;
 
 		if (!uhttp.base && !uhttp.use_cache && !uhttp.to && !uwsgi.sockets && !uhttp.subscription_server && !uhttp.use_cluster) {
-			char *rand_name = uwsgi_malloc(64);
-			snprintf(rand_name, 64, "%d_%d.sock", (int) time(NULL), (int) getpid());
-			uwsgi.sockets = uwsgi_new_socket(rand_name);
+			uwsgi_new_socket(uwsgi_concat2("127.0.0.1:0", ""));
 		}
 
 		uhttp.server = bind_to_tcp(uhttp.socket_name, uwsgi.listen_queue, strchr(uhttp.socket_name,':'));

plugins/jvm/uwsgiplugin.py

@@ -16,6 +16,16 @@ NAME='jvm'
 JVM_INCPATH = "/usr/lib/jvm/java-6-sun-1.6.0.15/include/ -I/usr/lib/jvm/java-6-sun-1.6.0.15/include/linux"
 JVM_LIBPATH = "/usr/lib/jvm/java-6-sun-1.6.0.15/jre/lib/i386/server/"
 
+try: 
+    JVM_INCPATH = os.environ['UWSGICONFIG_JVM_INCPATH'] 
+except: 
+    pass 
+
+try: 
+    JVM_LIBPATH = os.environ['UWSGICONFIG_JVM_LIBPATH'] 
+except: 
+    pass 
+
 try:
     JVM_INCPATH = os.environ['UWSGICONFIG_JVM_INCPATH']
 except:

plugins/nagios/nagios.c

@@ -16,7 +16,7 @@ struct option nagios_options[] = {
 int nagios() {
 
 	char *tcp_port;
-	struct pollfd nagios_poll;
+	struct wsgi_request nagios_req;
 // connect and send
 
 	if (!use_nagios) {
@@ -34,27 +34,30 @@ int nagios() {
 
 	tcp_port[0] = 0;
 
-	nagios_poll.fd = connect_to_tcp(uwsgi.sockets->name, atoi(tcp_port + 1), uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], 0);
-	if (nagios_poll.fd < 0) {
+	int fd = connect_to_tcp(uwsgi.sockets->name, atoi(tcp_port + 1), uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], 0);
+	if (fd < 0) {
 		fprintf(stdout, "UWSGI CRITICAL: could not connect() to workers\n");
 		exit(2);
 	}
-	uwsgi.wsgi_req->uh.modifier1 = UWSGI_MODIFIER_PING;
-	uwsgi.wsgi_req->uh.pktsize = 0;
-	uwsgi.wsgi_req->uh.modifier2 = 0;
-	if (write(nagios_poll.fd, uwsgi.wsgi_req, 4) != 4) {
+	nagios_req.uh.modifier1 = UWSGI_MODIFIER_PING;
+	nagios_req.uh.pktsize = 0;
+	nagios_req.uh.modifier2 = 0;
+	if (write(fd, &nagios_req.uh, 4) != 4) {
 		uwsgi_error("write()");
 		fprintf(stdout, "UWSGI CRITICAL: could not send ping packet to workers\n");
 		exit(2);
 	}
-	nagios_poll.events = POLLIN;
-	if (!uwsgi_parse_response(&nagios_poll, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], (struct uwsgi_header *) uwsgi.wsgi_req, uwsgi.wsgi_req->buffer, uwsgi_proto_uwsgi_parser)) {
+
+	nagios_req.poll.fd = fd;
+	nagios_req.poll.events = POLLIN;
+
+	if (!uwsgi_parse_packet(&nagios_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT])) {
 		fprintf(stdout, "UWSGI CRITICAL: timed out waiting for response\n");
 		exit(2);
 	}
 	else {
-		if (uwsgi.wsgi_req->uh.pktsize > 0) {
-			fprintf(stdout, "UWSGI WARNING: %.*s\n", uwsgi.wsgi_req->uh.pktsize, uwsgi.wsgi_req->buffer);
+		if (nagios_req.uh.pktsize > 0) {
+			fprintf(stdout, "UWSGI WARNING: %.*s\n", nagios_req.uh.pktsize, nagios_req.buffer);
 			exit(1);
 		}
 		else {

plugins/ping/ping_plugin.c

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

plugins/proxy/proxy.c

@@ -1,490 +0,0 @@
-/*
-
-   uWSGI proxy
-
-   it needs one of this tecnology to work:
-
-   - epoll (linux 2.6)
-   - kqueue (various BSD and Darwin)
-   - /dev/poll (Solaris)
-
-*/
-
-#include "../../uwsgi.h"
-
-#define LONG_ARGS_PROXY_WORKERS 50000
-
-struct uwsgi_proxy {
-	char *socket_name;
-	int add_me;
-	int workers;
-	int fd;
-} uproxy;
-
-struct option proxy_options[] = {
-	{"proxy", required_argument, 0, LONG_ARGS_PROXY},
-        {"proxy-node", required_argument, 0, LONG_ARGS_PROXY_NODE},
-        {"proxy-max-connections", required_argument, 0, LONG_ARGS_PROXY_MAX_CONNECTIONS},
-        {"proxy-workers", required_argument, 0, LONG_ARGS_PROXY_WORKERS},
-	{0, 0, 0, 0},	
-};
-
-#define UWSGI_PROXY_CONNECTING	1
-#define UWSGI_PROXY_WAITING	2
-
-extern struct uwsgi_server uwsgi;
-
-struct uwsgi_proxy_connection {
-
-	int dest_fd;
-	int status;
-	int retry;
-	int node;
-};
-
-static void end_proxy(void) {
-	exit(UWSGI_END_CODE);
-}
-
-
-static void reload_proxy(void) {
-	exit(UWSGI_RELOAD_CODE);
-}
-
-static void uwsgi_proxy_close(struct uwsgi_proxy_connection *upcs, int fd) {
-
-	if (upcs[fd].dest_fd >= 0) {
-		close(upcs[fd].dest_fd);
-		upcs[upcs[fd].dest_fd].dest_fd = -1;
-		upcs[upcs[fd].dest_fd].status = 0;
-		upcs[upcs[fd].dest_fd].retry = 0;
-		if (upcs[upcs[fd].dest_fd].node > -1) {
-			if (uwsgi.shared->nodes[upcs[upcs[fd].dest_fd].node].connections > 0)
-				uwsgi.shared->nodes[upcs[upcs[fd].dest_fd].node].connections--;
-		}
-	}
-
-	if (fd >= 0) {
-		close(fd);
-		upcs[fd].dest_fd = -1;
-		upcs[fd].status = 0;
-		upcs[fd].retry = 0;
-		if (upcs[fd].node > -1) {
-			if (uwsgi.shared->nodes[upcs[fd].node].connections > 0)
-				uwsgi.shared->nodes[upcs[fd].node].connections--;
-		}
-	}
-}
-
-static int uwsgi_proxy_find_next_node(int current_node) {
-	int i;
-
-	current_node++;
-	if (current_node >= MAX_CLUSTER_NODES) {
-		current_node = 0;
-	}
-
-	// is it a good node ?
-	if (uwsgi.shared->nodes[current_node].name[0] != 0 && uwsgi.shared->nodes[current_node].status == UWSGI_NODE_OK) {
-		if (uwsgi.shared->nodes[current_node].connections < uwsgi.shared->nodes[current_node].workers)
-			return current_node;
-	}
-
-	// try to find a better one
-
-	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-		if (uwsgi.shared->nodes[i].name[0] != 0 && uwsgi.shared->nodes[i].status == UWSGI_NODE_OK) {
-			if (uwsgi.shared->nodes[i].connections < uwsgi.shared->nodes[i].workers)
-				return i;
-		}
-	}
-
-	// ok, it is a very loaded system, fallback to round robin
-	if (uwsgi.shared->nodes[current_node].name[0] != 0 && uwsgi.shared->nodes[current_node].status == UWSGI_NODE_OK) {
-		return current_node;
-	}
-
-	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
-		if (uwsgi.shared->nodes[i].name[0] != 0 && uwsgi.shared->nodes[i].status == UWSGI_NODE_OK) {
-			return i;
-		}
-	}
-
-	return -1;
-}
-
-void proxy_loop() {
-
-	int efd;
-
-#ifdef __linux__
-	struct epoll_event *eevents;
-	struct epoll_event ev;
-#elif defined(__sun__)
-	struct pollfd *eevents;
-	struct pollfd ev;
-#else
-	struct kevent *eevents;
-	struct kevent ev;
-#endif
-
-	int max_events = 64;
-	int nevents, i;
-	const int nonblocking = 1;
-	const int blocking = 0;
-
-	char buffer[4096];
-	ssize_t rlen;
-	ssize_t wlen;
-	int max_connections = sysconf(_SC_OPEN_MAX);
-
-	int soopt;
-	socklen_t solen = sizeof(int);
-
-	int rc;
-
-	struct uwsgi_proxy_connection *upcs;
-
-	struct sockaddr_in upc_addr;
-	socklen_t upc_len = sizeof(struct sockaddr_in);
-
-	int next_node = -1;
-
-#ifdef UWSGI_DEBUG
-	uwsgi_log( "allocating space for %d concurrent proxy connections\n", max_connections);
-#endif
-
-	// allocate memory for connections
-	upcs = malloc(sizeof(struct uwsgi_proxy_connection) * max_connections);
-	if (!upcs) {
-		uwsgi_error("malloc()");
-		exit(1);
-	}
-	memset(upcs, 0, sizeof(struct uwsgi_proxy_connection) * max_connections);
-
-	if (uproxy.add_me) {
-                uwsgi_cluster_simple_add_node(uwsgi.sockets[0].name, 1, CLUSTER_NODE_STATIC);
-        }
-
-	efd = async_queue_init(uproxy.fd);
-	if (efd < 0) {
-		exit(1);
-	}
-
-#ifdef __linux__
-	eevents = malloc(sizeof(struct epoll_event) * max_events);
-	memset(&ev, 0, sizeof(struct epoll_event));
-#elif defined(__sun)
-	eevents = malloc(sizeof(struct pollfd) * max_events);
-	memset(&ev, 0, sizeof(struct pollfd));
-#else
-	eevents = malloc(sizeof(struct kevent) * max_events);
-	memset(&ev, 0, sizeof(struct kevent));
-#endif
-
-	if (!eevents) {
-		uwsgi_error("malloc()");
-		exit(1);
-	}
-
-	signal(SIGINT, (void *) &end_proxy);
-	signal(SIGTERM, (void *) &reload_proxy);
-	signal(SIGHUP, (void *) &reload_proxy);
-	// and welcome to the loop...
-
-	for (;;) {
-
-		nevents = async_wait(efd, eevents, max_events, -1, 0);
-		if (nevents < 0) {
-			uwsgi_error("epoll_wait()");
-			continue;
-		}
-
-		for (i = 0; i < nevents; i++) {
-
-			if ( (int)eevents[i].ASYNC_FD == uproxy.fd) {
-
-				if (eevents[i].ASYNC_IS_IN) {
-					// new connection, accept it
-					ev.ASYNC_FD = accept(uproxy.fd, (struct sockaddr *) &upc_addr, &upc_len);
-					if ( (int) ev.ASYNC_FD < 0) {
-						uwsgi_error("accept()");
-						continue;
-					}
-					upcs[ev.ASYNC_FD].node = -1;
-
-					// now connect to the first worker available
-
-					upcs[ev.ASYNC_FD].dest_fd = socket(AF_INET, SOCK_STREAM, 0);
-					if (upcs[ev.ASYNC_FD].dest_fd < 0) {
-						uwsgi_error("socket()");
-						uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-						continue;
-					}
-					upcs[upcs[ev.ASYNC_FD].dest_fd].node = -1;
-
-					// set nonblocking
-					if (ioctl(upcs[ev.ASYNC_FD].dest_fd, FIONBIO, &nonblocking)) {
-						uwsgi_error("ioctl()");
-						uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-						continue;
-					}
-
-					upcs[ev.ASYNC_FD].status = 0;
-					upcs[ev.ASYNC_FD].retry = 0;
-					next_node = uwsgi_proxy_find_next_node(next_node);
-					if (next_node == -1) {
-						uwsgi_log( "unable to find an available worker in the cluster !\n");
-						uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-						continue;
-					}
-					upcs[upcs[ev.ASYNC_FD].dest_fd].node = next_node;
-					rc = connect(upcs[ev.ASYNC_FD].dest_fd, (struct sockaddr *) &uwsgi.shared->nodes[next_node].ucn_addr, sizeof(struct sockaddr_in));
-					uwsgi.shared->nodes[next_node].connections++;
-
-					if (!rc) {
-						// connected to worker, put it in the epoll_list
-
-						if (async_add(efd, ev.ASYNC_FD, ASYNC_IN)) {
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-
-						upcs[upcs[ev.ASYNC_FD].dest_fd].dest_fd = ev.ASYNC_FD;
-						upcs[upcs[ev.ASYNC_FD].dest_fd].status = 0;
-						upcs[upcs[ev.ASYNC_FD].dest_fd].retry = 0;
-
-						ev.ASYNC_FD = upcs[ev.ASYNC_FD].dest_fd;
-
-						if (async_add(efd, ev.ASYNC_FD, ASYNC_IN)) {
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-
-						// re-set blocking
-						if (ioctl(upcs[upcs[ev.ASYNC_FD].dest_fd].dest_fd, FIONBIO, &blocking)) {
-							uwsgi_error("ioctl()");
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-
-					}
-					else if (errno == EINPROGRESS) {
-						// the socket is waiting, set status to CONNECTING
-						upcs[ev.ASYNC_FD].status = UWSGI_PROXY_WAITING;
-						upcs[upcs[ev.ASYNC_FD].dest_fd].dest_fd = ev.ASYNC_FD;
-						upcs[upcs[ev.ASYNC_FD].dest_fd].status = UWSGI_PROXY_CONNECTING;
-						upcs[upcs[ev.ASYNC_FD].dest_fd].retry = 0;
-
-						ev.ASYNC_FD = upcs[ev.ASYNC_FD].dest_fd;
-						if (async_add(efd, ev.ASYNC_FD, ASYNC_OUT)) {
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-					}
-					else {
-						// connection failed, retry with the next node ?
-						uwsgi_error("connect()");
-						// close only when all node are tried
-						uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-						continue;
-					}
-
-
-				}
-				else {
-					uwsgi_log( "!!! something horrible happened to the uWSGI proxy, reloading it !!!\n");
-					exit(1);
-				}
-			}
-			else {
-				// this is for clients/workers
-				if (eevents[i].ASYNC_IS_IN) {
-
-					// is this a connected client/worker ?
-					//uwsgi_log("ready %d\n", upcs[eevents[i].data.fd].status);
-
-					if (!upcs[eevents[i].ASYNC_FD].status) {
-						if (upcs[eevents[i].ASYNC_FD].dest_fd >= 0) {
-
-							rlen = read(eevents[i].ASYNC_FD, buffer, 4096);
-							if (rlen < 0) {
-								uwsgi_error("read()");
-								uwsgi_proxy_close(upcs, eevents[i].ASYNC_FD);
-								continue;
-							}
-							else if (rlen == 0) {
-								uwsgi_proxy_close(upcs, eevents[i].ASYNC_FD);
-								continue;
-							}
-							else {
-								wlen = write(upcs[eevents[i].ASYNC_FD].dest_fd, buffer, rlen);
-								if (wlen != rlen) {
-									uwsgi_error("write()");
-									uwsgi_proxy_close(upcs, eevents[i].ASYNC_FD);
-									continue;
-								}
-							}
-						}
-						else {
-							uwsgi_proxy_close(upcs, eevents[i].ASYNC_FD);
-							continue;
-						}
-					}
-					else if (upcs[eevents[i].ASYNC_FD].status == UWSGI_PROXY_WAITING) {
-						// disconnected node
-						continue;
-					}
-					else {
-						uwsgi_log( "UNKNOWN STATUS %d\n", upcs[eevents[i].ASYNC_FD].status);
-						continue;
-					}
-				}
-				else if (eevents[i].ASYNC_IS_OUT) {
-					if (upcs[eevents[i].ASYNC_FD].status == UWSGI_PROXY_CONNECTING) {
-
-
-#ifdef UWSGI_PROXY_USE_KQUEUE
-						if (getsockopt(eevents[i].ASYNC_FD, SOL_SOCKET, SO_ERROR, (void *) (&soopt), &solen) < 0) {
-							uwsgi_error("getsockopt()");
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-						/* is something bad ? */
-						if (soopt) {
-							uwsgi_log( "connect() %s\n", strerror(soopt));
-							// increase errors on node
-							uwsgi_log( "*** marking cluster node %d/%s as failed ***\n", upcs[eevents[i].ASYNC_FD].node, uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].name);
-							if (uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].type == CLUSTER_NODE_DYNAMIC) {
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].name[0] = 0 ;	
-							}
-							else {
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].errors++;
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].status = UWSGI_NODE_FAILED;
-							}
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-
-						// increase errors on node
-#endif
-						ev.ASYNC_FD = upcs[eevents[i].ASYNC_FD].dest_fd;
-						upcs[ev.ASYNC_FD].status = 0;
-						if (async_add(efd, ev.ASYNC_FD, ASYNC_IN)) {
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-
-						ev.ASYNC_FD = upcs[ev.ASYNC_FD].dest_fd;
-						upcs[ev.ASYNC_FD].status = 0;
-
-						if (async_mod(efd, ev.ASYNC_FD, ASYNC_IN)) {
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-						// re-set blocking
-						if (ioctl(ev.ASYNC_FD, FIONBIO, &blocking)) {
-							uwsgi_error("ioctl()");
-							uwsgi_proxy_close(upcs, ev.ASYNC_FD);
-							continue;
-						}
-					}
-					else {
-						uwsgi_log( "strange event for %d\n", (int) eevents[i].ASYNC_FD);
-					}
-				}
-				else {
-					if (upcs[eevents[i].ASYNC_FD].status == UWSGI_PROXY_CONNECTING) {
-						if (getsockopt(eevents[i].ASYNC_FD, SOL_SOCKET, SO_ERROR, (void *) (&soopt), &solen) < 0) {
-							uwsgi_error("getsockopt()");
-						}
-						/* is something bad ? */
-						if (soopt) {
-							uwsgi_log( "connect() %s\n", strerror(soopt));
-						}
-
-						// increase errors on node
-						uwsgi_log( "*** marking cluster node %d/%s as failed ***\n", upcs[eevents[i].ASYNC_FD].node, uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].name);
-							if (uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].type == CLUSTER_NODE_DYNAMIC) {
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].name[0] = 0;
-							}
-							else {
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].errors++;
-								uwsgi.shared->nodes[upcs[eevents[i].ASYNC_FD].node].status = UWSGI_NODE_FAILED;
-							}
-					}
-					else {
-						uwsgi_log( "STRANGE EVENT !!! %d %d %d\n", (int) eevents[i].ASYNC_FD, (int) eevents[i].ASYNC_EV, upcs[eevents[i].ASYNC_FD].status);
-					}
-					uwsgi_proxy_close(upcs, eevents[i].ASYNC_FD);
-					continue;
-				}
-			}
-		}
-	}
-}
-
-int proxy_init() {
-	int i;
-	char *tcp_port;
-
-	if (!uproxy.workers) uproxy.workers = 1 ;
-
-	if (uproxy.socket_name) {
-
-		tcp_port = strchr(uproxy.socket_name, ':');
-
-        	if (tcp_port == NULL) {
-                	uproxy.fd = bind_to_unix(uproxy.socket_name, UWSGI_LISTEN_QUEUE, uwsgi.chmod_socket, uwsgi.abstract_socket);
-        	}
-        	else {
-                	uproxy.fd = bind_to_tcp(uproxy.socket_name, UWSGI_LISTEN_QUEUE, tcp_port);
-                	tcp_port[0] = ':';
-        	}
-
-        	if (uproxy.fd < 0) {
-                	uwsgi_log( "unable to create the proxy server socket.\n");
-                	exit(1);
-        	}
-
-		for(i=0;i<uproxy.workers;i++) {
-			if (register_gateway("proxy", proxy_loop) == NULL) {
-				uwsgi_log("unable to register the proxy gateway\n");
-			}
-		}
-	}
-
-	return 0;
-}
-	
-int proxy_opt(int i, char *optarg) {
-
-        switch(i) {
-
-		case LONG_ARGS_PROXY_NODE:
-                        if (uwsgi.cluster_fd >= 0 && !strcmp(optarg, "@self")) {
-                                uproxy.add_me = 1;
-                        }
-                        else {
-                                uwsgi_cluster_simple_add_node(optarg, 1, CLUSTER_NODE_STATIC);
-                        }
-                        return 1;
-                case LONG_ARGS_PROXY:
-                        uproxy.socket_name = optarg;
-                        return 1;
-		case LONG_ARGS_PROXY_WORKERS:
-			uproxy.workers = atoi(optarg);
-			return 1;
-	}
-
-	return 0;
-}
-
-
-struct uwsgi_plugin proxy_plugin = {
-
-        .options = proxy_options,
-        .manage_opt = proxy_opt,
-        .init = proxy_init,
-};
-

plugins/proxy/uwsgiplugin.py

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

plugins/psgi/psgi_plugin.c

@@ -3,7 +3,11 @@
 extern char **environ;
 extern struct uwsgi_server uwsgi;
 
+#ifdef __APPLE__
+extern struct uwsgi_perl uperl;
+#else
 struct uwsgi_perl uperl;
+#endif
 
 struct option uwsgi_perl_options[] = {
 
@@ -257,6 +261,10 @@ SV *build_psgi_env(struct wsgi_request *wsgi_req) {
 	
 	if (!hv_store(env, "psgix.input.buffered", 20, newSViv(wsgi_req->body_as_file), 0)) goto clear;
 
+	if (uwsgi.master_process) {
+		if (!hv_store(env, "psgix.harakiri", 14, newSViv(1), 0)) goto clear;
+	}
+
 	SV *pe = uwsgi_perl_obj_new("uwsgi::error", 12);
         if (!hv_store(env, "psgi.errors", 11, pe, 0)) goto clear;
 
@@ -281,6 +289,10 @@ int uwsgi_perl_init(){
 		uwsgi_error("setenv()");
 	}
 
+	if (setenv("PLACK_SERVER", "uwsgi", 0)) {
+		uwsgi_error("setenv()");
+	}
+
 #ifdef PERL_VERSION_STRING
 	uwsgi_log("initializing Perl %s environment\n", PERL_VERSION_STRING);
 #else
@@ -364,6 +376,7 @@ void uwsgi_perl_enable_threads() {
 
 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;
@@ -426,6 +439,12 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	}
 
 clear2:
+	// check for psgix.harakiri
+        harakiri = hv_fetch((HV*)SvRV( (SV*)wsgi_req->async_environ), "psgix.harakiri.commit", 21, 0);
+        if (harakiri) {
+                if (SvTRUE(*harakiri)) wsgi_req->async_plagued = 1;
+        }
+
 	SvREFCNT_dec(wsgi_req->async_environ);
 	SvREFCNT_dec(wsgi_req->async_result);
 clear:
@@ -441,6 +460,12 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
 
 	if (uwsgi.shared->options[UWSGI_OPTION_LOGGING])
 		log_request(wsgi_req);
+
+	if (wsgi_req->async_plagued) {
+		uwsgi_log("*** psgix.harakiri.commit requested ***\n");
+		goodbye_cruel_world();
+	}
+
 }
 
 void uwsgi_perl_init_thread(int core_id) {

plugins/psgi/psgi_response.c

@@ -57,6 +57,7 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
 	struct http_status_codes *http_sc;
 	int i,vi, base;
 	char *chitem;
+	SV **harakiri;
 
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
@@ -84,6 +85,12 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
                         	SvREFCNT_dec(closed);
                 	}
 
+			// check for psgix.harakiri
+        		harakiri = hv_fetch((HV*)SvRV( (SV*)wsgi_req->async_environ), "psgix.harakiri.commit", 21, 0);
+        		if (harakiri) {
+                		if (SvTRUE(*harakiri)) wsgi_req->async_plagued = 1;
+        		}
+
 			SvREFCNT_dec(wsgi_req->async_environ);
         		SvREFCNT_dec(wsgi_req->async_result);
 

plugins/psgi/uwsgi_plmodule.c

@@ -66,7 +66,7 @@ XS(XS_wait_fd_write) {
         }
 
         if (fd >= 0) {
-                async_add_fd_read(wsgi_req, fd, timeout);
+                async_add_fd_write(wsgi_req, fd, timeout);
         }
 
 	wsgi_req->async_force_again = 1;

plugins/python/gil.c

@@ -4,15 +4,19 @@ extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
 void gil_real_get() {
+	//uwsgi_log("LOCK %d\n", uwsgi.mywid);
 #ifndef PYTHREE
 	PyEval_AcquireLock();
 	PyThreadState_Swap((PyThreadState *) pthread_getspecific(up.upt_gil_key));
 #else
 	PyEval_RestoreThread((PyThreadState *) pthread_getspecific(up.upt_gil_key));
 #endif
+
+	//uwsgi_log("LOCKED !!! %d\n", uwsgi.mywid);
 }
 
 void gil_real_release() {
+	//uwsgi_log("UNLOCK %d\n", uwsgi.mywid);
 #ifndef PYTHREE
 	pthread_setspecific(up.upt_gil_key, (void *) PyThreadState_Swap(NULL));
 	PyEval_ReleaseLock();	

plugins/python/pyloader.c

@@ -38,7 +38,6 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 
 	struct uwsgi_app *wi;
 
-
 	if (wsgi_req->script_name_len == 0) {
 		wsgi_req->script_name = "";
 	}
@@ -50,7 +49,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 
 
-	if (uwsgi.vhost && wsgi_req->host_len > 0) {
+	if (uwsgi.vhost) {
 		mountpoint = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|", 1, wsgi_req->script_name, wsgi_req->script_name_len);
 	}
 	else {
@@ -114,7 +113,6 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 					uwsgi_log("%s = %s\n", PyString_AsString(k), PyString_AsString(env_value));
 
                         		if (PyObject_SetItem(py_environ, k, env_value)) {
-						uwsgi_log("cazzo\n");
                                 		PyErr_Print();
                         		}
 
@@ -305,6 +303,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	if (uwsgi.threads > 1 && id) {
 		// if we have multiple threads we need to initialize a PyThreadState for each one
 		for(i=0;i<uwsgi.threads;i++) {
+			//uwsgi_log("%p\n", uwsgi.core[i]->ts[id]);
 			uwsgi.core[i]->ts[id] = PyThreadState_New( ((PyThreadState *)wi->interpreter)->interp);
 			if (!uwsgi.core[i]->ts[id]) {
 				uwsgi_log("unable to allocate new PyThreadState structure for app %s", mountpoint);
@@ -440,7 +439,7 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 	if (quick_callable[strlen(quick_callable) -2 ] == '(' && quick_callable[strlen(quick_callable) -1] ==')') {
 		quick_callable[strlen(quick_callable) -2 ] = 0;
 		tmp_callable = PyDict_GetItemString(wsgi_dict, quick_callable);
-		quick_callable[strlen(quick_callable) -2 ] = '(';
+		quick_callable[strlen(quick_callable)] = '(';
 		if (tmp_callable) {
 			return python_call(tmp_callable, PyTuple_New(0), 0);
 		}
@@ -521,8 +520,14 @@ PyObject *uwsgi_file_loader(void *arg1) {
 	PyObject *wsgi_file_module, *wsgi_file_dict;
 	PyObject *wsgi_file_callable;
 
+	char *callable = up.callable;
+	if (!callable) callable = "application";
+
 	wsgi_file_module = uwsgi_pyimport_by_filename("uwsgi_wsgi_file", filename);
-	// no need to check here for module import as it is already done by uwsgi_pyimport_by_file
+	if (!wsgi_file_module) {
+		PyErr_Print();
+		exit(1);
+	}
 
 	wsgi_file_dict = PyModule_GetDict(wsgi_file_module);
 	if (!wsgi_file_dict) {
@@ -530,7 +535,7 @@ PyObject *uwsgi_file_loader(void *arg1) {
 		exit(1);
 	}
 
-	wsgi_file_callable = PyDict_GetItemString(wsgi_file_dict, "application");
+	wsgi_file_callable = PyDict_GetItemString(wsgi_file_dict, callable);
 	if (!wsgi_file_callable) {
 		PyErr_Print();
 		uwsgi_log( "unable to find \"application\" callable in file %s\n", filename);

plugins/python/python_plugin.c

@@ -21,6 +21,11 @@ struct option uwsgi_python_options[] = {
 	{"pythonpath", required_argument, 0, LONG_ARGS_PYTHONPATH},
 	{"python-path", required_argument, 0, LONG_ARGS_PYTHONPATH},
 	{"pymodule-alias", required_argument, 0, LONG_ARGS_PYMODULE_ALIAS},
+	{"post-pymodule-alias", required_argument, 0, LONG_ARGS_POST_PYMODULE_ALIAS},
+	{"import", required_argument, 0, LONG_ARGS_PYIMPORT},
+	{"pyimport", required_argument, 0, LONG_ARGS_PYIMPORT},
+	{"py-import", required_argument, 0, LONG_ARGS_PYIMPORT},
+	{"python-import", required_argument, 0, LONG_ARGS_PYIMPORT},
 	{"pp", required_argument, 0, LONG_ARGS_PYTHONPATH},
 	{"pyargv", required_argument, 0, LONG_ARGS_PYARGV},
 	{"optimize", required_argument, 0, 'O'},
@@ -89,14 +94,15 @@ int uwsgi_python_init() {
 	if (up.home != NULL) {
 #ifdef PYTHREE
 		wchar_t *wpyhome;
-		wpyhome = malloc((sizeof(wchar_t) * strlen(up.home)) + 2);
+		wpyhome = malloc((sizeof(wchar_t) * strlen(up.home)) + sizeof(wchar_t) );
 		if (!wpyhome) {
 			uwsgi_error("malloc()");
 			exit(1);
 		}
 		mbstowcs(wpyhome, up.home, strlen(up.home));
 		Py_SetPythonHome(wpyhome);
-		free(wpyhome);
+		// do not free this memory !!!
+		//free(wpyhome);
 #else
 		Py_SetPythonHome(up.home);
 #endif
@@ -136,27 +142,32 @@ int uwsgi_python_init() {
 
 }
 
-void uwsgi_python_post_fork() {
+void uwsgi_python_reset_random_seed() {
 
 	PyObject *random_module, *random_dict, *random_seed;
 
-	// reinitialize the random seed (thanks Jonas Borgström)
-	random_module = PyImport_ImportModule("random");
-	if (random_module) {
-		random_dict = PyModule_GetDict(random_module);
-		if (random_dict) {
-			random_seed = PyDict_GetItemString(random_dict, "seed");
-			if (random_seed) {
-				PyObject *random_args = PyTuple_New(1);
-				// pass no args
-				PyTuple_SetItem(random_args, 0, Py_None);
-				PyEval_CallObject(random_seed, random_args);
-				if (PyErr_Occurred()) {
-					PyErr_Print();
-				}
-			}
-		}
-	}
+        // reinitialize the random seed (thanks Jonas Borgström)
+        random_module = PyImport_ImportModule("random");
+        if (random_module) {
+                random_dict = PyModule_GetDict(random_module);
+                if (random_dict) {
+                        random_seed = PyDict_GetItemString(random_dict, "seed");
+                        if (random_seed) {
+                                PyObject *random_args = PyTuple_New(1);
+                                // pass no args
+                                PyTuple_SetItem(random_args, 0, Py_None);
+                                PyEval_CallObject(random_seed, random_args);
+                                if (PyErr_Occurred()) {
+                                        PyErr_Print();
+                                }
+                        }
+                }
+        }
+}
+
+void uwsgi_python_post_fork() {
+
+	uwsgi_python_reset_random_seed();
 
 #ifdef UWSGI_EMBEDDED
 	// call the post_fork_hook
@@ -184,17 +195,17 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	char *real_filename = filename;
 
 
-	if (strncmp(filename, "http://", 7)) {
+	if (strncmp(filename, "http://", 7) && strncmp(filename, "sym://", 6)) {
 
 		pyfile = fopen(filename, "r");
 		if (!pyfile) {
 			uwsgi_log("failed to open python file %s\n", filename);
-			exit(1);
+			return NULL;
 		}
 
 		if (fstat(fileno(pyfile), &pystat)) {
 			uwsgi_error("fstat()");
-			exit(1);
+			return NULL;
 		}
 
 		if (S_ISDIR(pystat.st_mode)) {
@@ -204,7 +215,9 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 			pyfile = fopen(real_filename, "r");
 			if (!pyfile) {
 				uwsgi_error_open(real_filename);
-				exit(1);
+				free(real_filename);
+				fclose(pyfile);
+				return NULL;
 			}
 		}
 
@@ -212,7 +225,9 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 		if (!py_file_node) {
 			PyErr_Print();
 			uwsgi_log("failed to parse file %s\n", real_filename);
-			exit(1);
+			free(real_filename);
+			fclose(pyfile);
+			return NULL;
 		}
 
 		fclose(pyfile);
@@ -226,7 +241,7 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 			if (!py_file_node) {
 				PyErr_Print();
 				uwsgi_log("failed to parse url %s\n", real_filename);
-				exit(1);
+				return NULL;
 			}
 		}
 	}
@@ -236,13 +251,13 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	if (!py_compiled_node) {
 		PyErr_Print();
 		uwsgi_log("failed to compile python file %s\n", real_filename);
-		exit(1);
+		return NULL;
 	}
 
 	py_file_module = PyImport_ExecCodeModule(name, py_compiled_node);
 	if (!py_file_module) {
 		PyErr_Print();
-		exit(1);
+		return NULL;
 	}
 
 	Py_DECREF(py_compiled_node);
@@ -365,6 +380,10 @@ void init_uwsgi_vars() {
 		else {
 			// this is a filepath that need to be mapped
 			tmp_module = uwsgi_pyimport_by_filename(up.pymodule_alias[i], value + 1);
+			if (!tmp_module) {
+				PyErr_Print();
+				exit(1);
+			}
 		}
 		uwsgi_log("mapped virtual pymodule \"%s\" to real pymodule \"%s\"\n", up.pymodule_alias[i], value + 1);
 		// reset original value
@@ -428,6 +447,20 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	PyObject *uwsgi_py_version_info = PyTuple_New(5);
+
+	PyTuple_SetItem(uwsgi_py_version_info, 0, PyInt_FromLong(UWSGI_VERSION_BASE));
+	PyTuple_SetItem(uwsgi_py_version_info, 1, PyInt_FromLong(UWSGI_VERSION_MAJOR));
+	PyTuple_SetItem(uwsgi_py_version_info, 2, PyInt_FromLong(UWSGI_VERSION_MINOR));
+	PyTuple_SetItem(uwsgi_py_version_info, 3, PyInt_FromLong(UWSGI_VERSION_REVISION));
+	PyTuple_SetItem(uwsgi_py_version_info, 4, PyString_FromString(UWSGI_VERSION_CUSTOM));
+
+	if (PyDict_SetItemString(up.embedded_dict, "version_info", uwsgi_py_version_info)) {
+		PyErr_Print();
+		exit(1);
+	}
+
+
 	if (PyDict_SetItemString(up.embedded_dict, "hostname", PyString_FromStringAndSize(uwsgi.hostname, uwsgi.hostname_len))) {
 		PyErr_Print();
 		exit(1);
@@ -468,6 +501,11 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	if (PyDict_SetItemString(up.embedded_dict, "has_threads", PyInt_FromLong(uwsgi.has_threads))) {
+		PyErr_Print();
+		exit(1);
+	}
+
 	if (PyDict_SetItemString(up.embedded_dict, "cores", PyInt_FromLong(uwsgi.cores))) {
 		PyErr_Print();
 		exit(1);
@@ -480,39 +518,6 @@ void init_uwsgi_embedded_module() {
 		}
 	}
 
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_NULL", PyInt_FromLong(KIND_NULL))) {
-		PyErr_Print();
-		exit(1);
-	}
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_WORKER", PyInt_FromLong(KIND_WORKER))) {
-		PyErr_Print();
-		exit(1);
-	}
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_EVENT", PyInt_FromLong(KIND_EVENT))) {
-		PyErr_Print();
-		exit(1);
-	}
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_SPOOLER", PyInt_FromLong(KIND_SPOOLER))) {
-		PyErr_Print();
-		exit(1);
-	}
-
-/*
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_ERLANG", PyInt_FromLong(KIND_ERLANG))) {
-		PyErr_Print();
-		exit(1);
-	}
-*/
-
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_PROXY", PyInt_FromLong(KIND_PROXY))) {
-		PyErr_Print();
-		exit(1);
-	}
-	if (PyDict_SetItemString(up.embedded_dict, "KIND_MASTER", PyInt_FromLong(KIND_MASTER))) {
-		PyErr_Print();
-		exit(1);
-	}
-
 	PyObject *py_opt_dict = PyDict_New();
 	for (i = 0; i < uwsgi.exported_opts_cnt; i++) {
 		if (PyDict_Contains(py_opt_dict, PyString_FromString(uwsgi.exported_opts[i]->key))) {
@@ -692,6 +697,12 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 			uwsgi_log("you can specify at most %d --pymodule-alias options\n", MAX_PYMODULE_ALIAS);
 		}
 		return 1;
+	case LONG_ARGS_PYIMPORT:
+		uwsgi_string_new_list(&up.import_list, optarg);
+		return 1;
+	case LONG_ARGS_POST_PYMODULE_ALIAS:
+		uwsgi_string_new_list(&up.post_pymodule_alias, optarg);
+		return 1;
 	case LONG_ARGS_PYTHONPATH:
 		if (glob(optarg, GLOB_MARK, NULL, &g)) {
 			uwsgi_string_new_list(&up.python_path, optarg);
@@ -719,6 +730,7 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 		return 1;
 
 
+#ifdef UWSGI_INI
 	case LONG_ARGS_INI_PASTE:
 		uwsgi.ini = optarg;
 		if (uwsgi.ini[0] != '/') {
@@ -728,6 +740,7 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 			up.paste = uwsgi_concat2("config:", uwsgi.ini);
 		}
 		return 1;
+#endif
 	case LONG_ARGS_PASTE:
 		up.paste = optarg;
 		return 1;
@@ -750,18 +763,55 @@ int uwsgi_python_mount_app(char *mountpoint, char *app) {
 
 }
 
+char *uwsgi_pythonize(char *orig) {
+
+	char *name = uwsgi_concat2(orig, "");
+	size_t i;
+	size_t len = 0;
+
+	if (!strncmp(name, "sym://", 6)) {
+		name+=6;
+	}
+	else if (!strncmp(name, "http://", 7)) {
+		name+=7;
+	}
+
+	len = strlen(name);
+	for(i=0;i<len;i++) {
+		if (name[i] == '/') {
+			name[i] = '.';
+		}
+	}
+
+
+	if ((name[len-3] == '.' || name[len-3] == '_') && name[len-2] == 'p' && name[len-1] == 'y') {
+		name[len-3] = 0;
+	}
+
+	return name;
+
+}
+
 void uwsgi_python_init_apps() {
 
+
 	if (uwsgi.async > 1) {
 		up.current_recursion_depth = uwsgi_malloc(sizeof(int)*uwsgi.async);
         	up.current_frame = uwsgi_malloc(sizeof(struct _frame)*uwsgi.async);
 	}
 
 	init_pyargv();
+
 #ifdef UWSGI_MINTERPRETERS
         init_uwsgi_embedded_module();
 #endif
 
+#ifdef __linux__
+#ifndef PYTHREE
+	uwsgi_init_symbol_import();
+#endif
+#endif
+
         if (up.test_module != NULL) {
                 if (PyImport_ImportModule(up.test_module)) {
                         exit(0);
@@ -784,6 +834,56 @@ void uwsgi_python_init_apps() {
         up.loaders[LOADER_STRING_CALLABLE] = uwsgi_string_callable_loader;
 
 
+	struct uwsgi_string_list *upli = up.import_list;
+	while(upli) {
+		if (strchr(upli->value, '/') || uwsgi_endswith(upli->value, ".py")) {
+			uwsgi_pyimport_by_filename(uwsgi_pythonize(upli->value), upli->value);
+		}
+		else {
+			if (PyImport_ImportModule(upli->value) == NULL) {
+				PyErr_Print();
+			}
+		}
+		upli = upli->next;
+	}
+
+	struct uwsgi_string_list *uppa = up.post_pymodule_alias;
+	PyObject *modules = PyImport_GetModuleDict();
+	PyObject *tmp_module;
+	while(uppa) {
+                // split key=value
+                char *value = strchr(uppa->value, '=');
+                if (!value) {
+                        uwsgi_log("invalid pymodule-alias syntax\n");
+                        continue;
+                }
+                value[0] = 0;
+                if (!strchr(value + 1, '/')) {
+                        // this is a standard pymodule
+                        tmp_module = PyImport_ImportModule(value + 1);
+                        if (!tmp_module) {
+                                PyErr_Print();
+                                exit(1);
+                        }
+
+                        PyDict_SetItemString(modules, uppa->value, tmp_module);
+                }
+                else {
+                        // this is a filepath that need to be mapped
+                        tmp_module = uwsgi_pyimport_by_filename(uppa->value, value + 1);
+                        if (!tmp_module) {
+                                PyErr_Print();
+                                exit(1);
+                        }
+                }
+                uwsgi_log("mapped virtual pymodule \"%s\" to real pymodule \"%s\"\n", uppa->value, value + 1);
+                // reset original value
+                value[0] = '=';
+
+		uppa = uppa->next;
+        }
+
+
 	if (up.wsgi_config != NULL) {
 		init_uwsgi_app(LOADER_UWSGI, up.wsgi_config, uwsgi.wsgi_req, up.main_thread);
 	}
@@ -806,6 +906,29 @@ void uwsgi_python_init_apps() {
 
 }
 
+void uwsgi_python_master_fixup(int step) {
+
+	static int master_fixed = 0;
+	static int worker_fixed = 0;
+
+	if (!uwsgi.master_process) return;
+
+	if (uwsgi.has_threads) {
+		if (step == 0) {
+			if (!master_fixed) {
+				UWSGI_RELEASE_GIL;
+				master_fixed = 1;
+			}
+		}	
+		else {
+			if (!worker_fixed) {
+				UWSGI_GET_GIL;
+				worker_fixed = 1;
+			}
+		}
+	}
+}
+
 void uwsgi_python_enable_threads() {
 
 	PyEval_InitThreads();
@@ -825,9 +948,12 @@ void uwsgi_python_enable_threads() {
 	up.gil_get = gil_real_get;
 	up.gil_release = gil_real_release;
 
-	up.swap_ts = threaded_swap_ts;
-	up.reset_ts = threaded_reset_ts;
+	if (uwsgi.threads > 1) {
+		up.swap_ts = threaded_swap_ts;
+		up.reset_ts = threaded_reset_ts;
+	}
 	uwsgi_log("threads support enabled\n");
+
 }
 
 void uwsgi_python_init_thread(int core_id) {
@@ -976,44 +1102,67 @@ void uwsgi_python_add_item(char *key, uint16_t keylen, char *val, uint16_t valle
 	PyDict_SetItem(pydict, PyString_FromStringAndSize(key, keylen), PyString_FromStringAndSize(val, vallen));
 }
 
-int uwsgi_python_spooler(char *buf, uint16_t len) {
+int uwsgi_python_spooler(char *filename, char *buf, uint16_t len, char *body, size_t body_len) {
+
+	static int random_seed_reset = 0;
+
+	UWSGI_GET_GIL;
 
 	PyObject *spool_dict = PyDict_New();
 	PyObject *spool_func, *pyargs, *ret;
 
+	if (!random_seed_reset) {
+		uwsgi_python_reset_random_seed();
+		random_seed_reset = 1;	
+	}
+
 	if (!up.embedded_dict) {
 		// ignore
+		UWSGI_RELEASE_GIL;
 		return 0;
 	}
 
 	spool_func = PyDict_GetItemString(up.embedded_dict, "spooler");
 	if (!spool_func) {
 		// ignore
+		UWSGI_RELEASE_GIL;
 		return 0;
 	}
 
 	if (uwsgi_hooked_parse(buf, len, uwsgi_python_add_item, spool_dict)) {
 		// malformed packet, destroy it
+		UWSGI_RELEASE_GIL;
 		return -2;
 	}
 
 	pyargs = PyTuple_New(1);
+
+	PyDict_SetItemString(spool_dict, "spooler_task_name", PyString_FromString(filename));
+
+	if (body && body_len > 0) {
+		PyDict_SetItemString(spool_dict, "body", PyString_FromStringAndSize(body, body_len));
+	}
 	PyTuple_SetItem(pyargs, 0, spool_dict);
 	
 	ret = python_call(spool_func, pyargs, 0);
 	if (ret) {
 		if (!PyInt_Check(ret)) {
 			// error, retry
+			UWSGI_RELEASE_GIL;
 			return -1;
 		}	
 
-		return PyInt_AsLong(ret);
+		int retval = (int) PyInt_AsLong(ret);
+		UWSGI_RELEASE_GIL;
+		return retval;
+		
 	}
 	
 	if (PyErr_Occurred())
 		PyErr_Print();
 
 	// error, retry
+	UWSGI_RELEASE_GIL;
 	return -1;
 }
 
@@ -1052,6 +1201,7 @@ struct uwsgi_plugin python_plugin = {
 	.init_apps = uwsgi_python_init_apps,
 
 	.fixup = uwsgi_python_fixup,
+	.master_fixup = uwsgi_python_master_fixup,
 
 	.mount_app = uwsgi_python_mount_app,
 

plugins/python/pyutils.c

@@ -12,8 +12,12 @@ PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
 
 	PyObject *pyret;
 
+	//uwsgi_log("ready to call %p %p\n", callable, args);
+
 	pyret =  PyEval_CallObject(callable, args);
 
+	//uwsgi_log("called\n");
+
 	if (PyErr_Occurred()) {
 		if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
 			uwsgi_log("Memory Error detected !!!\n");

plugins/python/symimporter.c

@@ -0,0 +1,222 @@
+#include "uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+
+
+struct _symimporter {
+	PyObject_HEAD;
+} uwsgi_symbol_importer_object;
+
+static char *symbolize(char *name) {
+
+	char *base = uwsgi_concat2(name, "");
+	char *ptr = base;
+	while(*ptr != 0) {
+		if (*ptr == '.') {
+			*ptr = '_';
+		}
+		ptr++;
+	}
+
+	return base;
+}
+
+static char *name_to_symbol_module(char *name, char *what) {
+
+	char *symbol = uwsgi_concat4("_binary_", name, "_py_", what);
+        char *sym_ptr_start = dlsym(RTLD_DEFAULT, symbol);
+	free(symbol);
+	return sym_ptr_start;
+}
+
+static char *name_to_symbol_pkg(char *name, char *what) {
+
+	char *symbol = uwsgi_concat4("_binary_", name, "___init___py_", what);
+        char *sym_ptr_start = dlsym(RTLD_DEFAULT, symbol);
+	free(symbol);
+	return sym_ptr_start;
+}
+
+static PyObject* symimporter_find_module(PyObject *self, PyObject *args) {
+
+	char *fullname;
+	PyObject *path = NULL;
+
+	if (!PyArg_ParseTuple(args, "s|O:find_module", &fullname, &path)) {
+		return NULL;
+	}
+
+	char *fullname2 = symbolize(fullname);
+
+	char *code_start = name_to_symbol_module(fullname2, "start");
+	if (code_start) {
+		free(fullname2);
+		Py_INCREF(self);
+		return self;
+	}
+	code_start = name_to_symbol_pkg(fullname2, "start");
+	if (code_start) {
+		free(fullname2);
+		Py_INCREF(self);
+		return self;
+	}
+	
+	
+	free(fullname2);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject* symimporter_load_module(PyObject *self, PyObject *args) {
+
+	char *code_start;
+	char *code_end;
+	char *fullname;
+	char *source;
+	char *modname;
+	PyObject *code;
+	if (!PyArg_ParseTuple(args, "s:load_module", &fullname)) {
+                return NULL;
+        }
+
+	char *fullname2 = symbolize(fullname);
+
+	code_start = name_to_symbol_module(fullname2, "start");
+	if (code_start) {
+		code_end = name_to_symbol_module(fullname2, "end");
+		if (code_end) {
+			PyObject *mod = PyImport_AddModule(fullname);
+			if (!mod) goto clear;
+			PyObject *dict = PyModule_GetDict(mod);
+			if (!dict) goto clear;
+
+			PyDict_SetItemString(dict, "__loader__", self);
+
+			source = uwsgi_concat2n(code_start, code_end-code_start, "", 0);
+			modname = uwsgi_concat3("sym://", fullname2, "_py");
+
+			code = Py_CompileString(source, modname, Py_file_input);
+			mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+			Py_DECREF(code);
+			free(source);
+			free(modname);
+			free(fullname2);
+			return mod;	
+		}
+	}
+
+	code_start = name_to_symbol_pkg(fullname2, "start");
+        if (code_start) {
+                code_end = name_to_symbol_pkg(fullname2, "end");
+                if (code_end) {
+                        PyObject *mod = PyImport_AddModule(fullname);
+			if (!mod) goto clear;
+                        PyObject *dict = PyModule_GetDict(mod);
+			if (!dict) goto clear;
+
+                        source = uwsgi_concat2n(code_start, code_end-code_start, "", 0);
+			modname = uwsgi_concat3("sym://", symbolize(fullname), "___init___py");
+
+			PyObject *pkgpath = Py_BuildValue("[O]", PyString_FromString(modname));
+
+			PyDict_SetItemString(dict, "__path__", pkgpath);
+			PyDict_SetItemString(dict, "__loader__", self);
+
+                        code = Py_CompileString(source, modname, Py_file_input);
+                        mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+			Py_DECREF(code);
+			free(source);
+			free(modname);
+			free(fullname2);
+                        return mod;
+                }
+        }
+
+clear:
+	free(fullname2);
+	Py_INCREF(Py_None);
+        return Py_None;
+}
+
+static PyMethodDef symimporter_methods[] = {
+    {"find_module", symimporter_find_module, METH_VARARGS},
+    {"load_module", symimporter_load_module, METH_VARARGS},
+};
+
+static void uwsgi_symimporter_free(struct _symimporter *self) {
+        PyObject_Del(self);
+}
+
+
+static PyTypeObject SymImporter_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "uwsgi.SymbolsImporter",
+    sizeof(struct _symimporter),
+    0,                                          /* tp_itemsize */
+    (destructor) uwsgi_symimporter_free,            /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,
+    "uwsgi symbols importer",                                          /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    symimporter_methods,                        /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                 /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
+    PyObject_GC_Del,                            /* tp_free */
+};
+
+int uwsgi_init_symbol_import() {
+
+
+	if (PyType_Ready(&SymImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols importer module\n");
+		exit(1);
+	}
+
+	PyObject *uwsgi_em = PyImport_ImportModule("uwsgi");
+	if (!uwsgi_em) {
+		PyErr_Print();
+		uwsgi_log("unable to get uwsgi module\n");
+		exit(1);
+	}
+
+	if (PyModule_AddObject(uwsgi_em, "SymbolsImporter",
+                           (PyObject *)&SymImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols importer object\n");
+		exit(1);
+	}
+
+        return 0;
+	
+}
+

plugins/python/uwsgi_pymodule.c

@@ -2,16 +2,74 @@
 
 #include "uwsgi_python.h"
 
-char *spool_buffer = NULL;
-
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
 PyObject *py_uwsgi_signal_wait(PyObject * self, PyObject * args) {
 
         struct wsgi_request *wsgi_req = current_wsgi_req();
+	int wait_for_specific_signal = 0;
+	uint8_t uwsgi_signal = 0;
+	uint8_t received_signal;
+	int ret;
+	struct pollfd pfd[2];
+
+	wsgi_req->signal_received = -1;
+
+	if (PyTuple_Size(args) > 0) {
+		if (!PyArg_ParseTuple(args, "|B:", &uwsgi_signal)) {
+                	return NULL;
+        	}
+		wait_for_specific_signal = 1;	
+	}
+
+#ifdef UWSGI_ASYNC
+	if (uwsgi.async > 1) {
+        	wsgi_req->sigwait = 1;
+	}
+	else {
+#endif
+		pfd[0].fd = uwsgi.signal_socket;
+		pfd[0].events = POLLIN;
+		pfd[1].fd = uwsgi.my_signal_socket;
+		pfd[1].events = POLLIN;
+cycle:
+		ret = poll(pfd, 2, -1);
+		if (ret > 0) {
+			if (pfd[0].revents == POLLIN) {
+				if (read(uwsgi.signal_socket, &received_signal, 1) != 1) {
+					uwsgi_error("read()");
+				}		
+				else {
+					if (uwsgi_signal_handler(received_signal)) {
+                                		uwsgi_log_verbose("error managing signal %d on worker %d\n", received_signal, uwsgi.mywid);
+                        		}
+					wsgi_req->signal_received = received_signal;			
+					if (wait_for_specific_signal) {
+						if (received_signal != uwsgi_signal) goto cycle;
+					}
+				}
+			}
+			if (pfd[1].revents == POLLIN) {
+                                if (read(uwsgi.my_signal_socket, &received_signal, 1) != 1) {
+                                        uwsgi_error("read()");
+                                }
+                                else {
+					if (uwsgi_signal_handler(received_signal)) {
+                                		uwsgi_log_verbose("error managing signal %d on worker %d\n", received_signal, uwsgi.mywid);
+                        		}
+                                        wsgi_req->signal_received = received_signal;
+                                        if (wait_for_specific_signal) {
+                                                if (received_signal != uwsgi_signal) goto cycle;
+                                        }
+                                }
+                        }
+		}
+
+#ifdef UWSGI_ASYNC
+	}
+#endif
 
-        wsgi_req->sigwait = 1;
 
         return PyString_FromString("");
 }
@@ -115,6 +173,7 @@ char *uwsgi_encode_pydict(PyObject * pydict, uint16_t * size) {
 
 		if (!key || !val) {
 			PyErr_Print();
+			continue;
 		}
 
 		if (!PyString_Check(key) || !PyString_Check(val)) {
@@ -309,15 +368,15 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 	char *node, *func;
 	uint16_t size = 0;
 	PyObject *py_node, *py_func;
-	struct uwsgi_header uh;
+	struct wsgi_request rpc_req;
 	int argc = PyTuple_Size(args);
 	char *argv[0xff];
 	int i, fd;
 	uint16_t pktsize = 0, ulen;
 	char *bufptr;
 	int rlen;
+	int rpc_args = 0;
 
-	struct pollfd upoll;
 
 	// TODO better error reporting
 	if (argc < 2)
@@ -341,10 +400,16 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 
 	for (i = 0; i < (argc - 2); i++) {
 		argv[i] = PyString_AsString(PyTuple_GetItem(args, i + 2));
+		rpc_args++;
 	}
 
-	if (node == (char *) "") {
-		size = uwsgi_rpc(func, 0, NULL, buffer);
+	if (!strcmp(node, "")) {
+		if (!rpc_args) {
+			size = uwsgi_rpc(func, 0, NULL, buffer);
+		}
+		else {
+			size = uwsgi_rpc(func, rpc_args, argv, buffer);
+		}
 	}
 	else {
 
@@ -361,9 +426,11 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 			pktsize += 2 + strlen(argv[i]);
 		}
 
-		uh.modifier1 = 173;
-		uh.pktsize = pktsize;
-		uh.modifier2 = 0;
+		memset(&rpc_req, 0, sizeof(struct wsgi_request));
+
+		rpc_req.uh.modifier1 = 173;
+		rpc_req.uh.pktsize = pktsize;
+		rpc_req.uh.modifier2 = 0;
 
 		bufptr = buffer;
 
@@ -381,7 +448,7 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 			bufptr += ulen;
 		}
 
-		if (write(fd, &uh, 4) != 4) {
+		if (write(fd, &rpc_req.uh, 4) != 4) {
 			uwsgi_error("write()");
 			close(fd);
 			goto clear;
@@ -395,10 +462,11 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 
 		rlen = uwsgi_waitfd(fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
 		if (rlen > 0) {
-			upoll.fd = fd;
-			upoll.events = POLLIN;
-			if (uwsgi_parse_response(&upoll, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], &uh, buffer, uwsgi_proto_uwsgi_parser)) {
-				size = uh.pktsize;
+			rpc_req.poll.fd = fd;
+			rpc_req.poll.events = POLLIN;
+			rpc_req.buffer = buffer;
+			if (uwsgi_parse_packet(&rpc_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT])) {
+				size = rpc_req.uh.pktsize;
 			}
 		}
 
@@ -426,8 +494,7 @@ PyObject *py_uwsgi_register_rpc(PyObject * self, PyObject * args) {
 
 
 	if (uwsgi_register_rpc(name, 0, argc, func)) {
-		Py_INCREF(Py_None);
-		return Py_None;
+		return PyErr_Format(PyExc_ValueError, "unable to register rpc function");
 	}
 
 	Py_INCREF(Py_True);
@@ -451,6 +518,22 @@ PyObject *py_uwsgi_attach_daemon(PyObject * self, PyObject * args) {
 	return Py_True;
 }
 
+PyObject *py_uwsgi_signal_registered(PyObject * self, PyObject * args) {
+	uint8_t uwsgi_signal;
+
+	if (!PyArg_ParseTuple(args, "B:signal_registered", &uwsgi_signal)) {
+                return NULL;
+        }
+
+	if (uwsgi_signal_registered(uwsgi_signal)) {
+		Py_INCREF(Py_True);
+		return Py_True;
+	}
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
 PyObject *py_uwsgi_register_signal(PyObject * self, PyObject * args) {
 
 	uint8_t uwsgi_signal;
@@ -478,9 +561,11 @@ PyObject *py_uwsgi_signal(PyObject * self, PyObject * args) {
 		return NULL;
 	}
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("sending %d to master\n", uwsgi_signal);
+#endif
 
-	rlen = write(uwsgi.shared->worker_signal_pipe[1], &uwsgi_signal, 1);
+	rlen = write(uwsgi.signal_socket, &uwsgi_signal, 1);
 	if (rlen != 1) {
 		uwsgi_error("write()");
 	}
@@ -746,6 +831,7 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 	off_t pos = 0;
 	size_t filesize = 0;
 	struct stat stat_buf;
+	struct wsgi_request *wsgi_req = current_wsgi_req();
 
 	int fd = -1;
 
@@ -770,7 +856,7 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 			goto clear;
 
 		// check for mixing file_wrapper and sendfile
-		if (fd == uwsgi.wsgi_req->sendfile_fd) {
+		if (fd == wsgi_req->sendfile_fd) {
 			Py_INCREF(what);
 		}
 	}
@@ -792,7 +878,7 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 	if (!chunk)
 		chunk = 4096;
 
-	uwsgi.wsgi_req->response_size += uwsgi_do_sendfile(uwsgi.wsgi_req->poll.fd, fd, filesize, chunk, &pos, 0);
+	uwsgi.wsgi_req->response_size += uwsgi_do_sendfile(wsgi_req->poll.fd, fd, filesize, chunk, &pos, 0);
 
 	close(fd);
 	Py_INCREF(Py_True);
@@ -867,14 +953,13 @@ PyObject *py_uwsgi_log(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_lock(PyObject * self, PyObject * args) {
 
-	// the spooler, the master process or single process environment cannot lock resources
+	// the spooler cannot lock resources
 #ifdef UWSGI_SPOOLER
-	if (uwsgi.numproc > 1 && uwsgi.mypid != uwsgi.workers[0].pid && uwsgi.mypid != uwsgi.shared->spooler_pid) {
-#else
-	if (uwsgi.numproc > 1 && uwsgi.mypid != uwsgi.workers[0].pid) {
-#endif
-		uwsgi_lock(uwsgi.user_lock);
+	if (uwsgi.mypid == uwsgi.shared->spooler_pid) {
+		return PyErr_Format(PyExc_ValueError, "The spooler cannot lock/unlock resources");
 	}
+#endif
+	uwsgi_lock(uwsgi.user_lock);
 
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -882,12 +967,47 @@ PyObject *py_uwsgi_lock(PyObject * self, PyObject * args) {
 
 PyObject *py_uwsgi_unlock(PyObject * self, PyObject * args) {
 
+#ifdef UWSGI_SPOOLER
+	if (uwsgi.mypid == uwsgi.shared->spooler_pid) {
+		return PyErr_Format(PyExc_ValueError, "The spooler cannot lock/unlock resources");
+	}
+#endif
+
 	uwsgi_unlock(uwsgi.user_lock);
 
 	Py_INCREF(Py_None);
 	return Py_None;
 }
 
+PyObject *py_uwsgi_embedded_data(PyObject * self, PyObject * args) {
+
+	char *name;
+	char *symbol;
+	void *sym_ptr_start = NULL;
+	void *sym_ptr_end = NULL;
+
+	if (!PyArg_ParseTuple(args, "s:embedded_data", &name)) {
+		return NULL;
+	}
+
+	symbol = uwsgi_concat3("_binary_", name, "_start");
+	sym_ptr_start = dlsym(RTLD_DEFAULT, symbol);
+	free(symbol);
+	if (!sym_ptr_start)
+		return PyErr_Format(PyExc_ValueError, "unable to find symbol %s", name);
+
+
+
+	symbol = uwsgi_concat3("_binary_", name, "_end");
+	sym_ptr_end = dlsym(RTLD_DEFAULT, symbol);
+	free(symbol);
+	if (!sym_ptr_end)
+		return PyErr_Format(PyExc_ValueError, "unable to find symbol %s", name);
+
+	return PyString_FromStringAndSize(sym_ptr_start, sym_ptr_end - sym_ptr_start);
+
+}
+
 PyObject *py_uwsgi_sharedarea_inclong(PyObject * self, PyObject * args) {
 	int pos = 0;
 	long value = 0;
@@ -1127,6 +1247,11 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 	int i;
 	char spool_filename[1024];
 	struct wsgi_request *wsgi_req = current_wsgi_req();
+	char *priority = NULL;
+	long numprio = 0;
+	time_t at = 0;
+	char *body = NULL;
+	size_t body_len= 0;
 
 	spool_dict = PyTuple_GetItem(args, 0);
 
@@ -1147,12 +1272,47 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 		return PyErr_Format(PyExc_ValueError, "The argument of spooler callable must be a dictionary");
 	}
 
+	PyObject *pyprio = uwsgi_py_dict_get(spool_dict, "priority");
+	if (pyprio) {
+		if (PyInt_Check(pyprio)) {
+			numprio = PyInt_AsLong(pyprio);
+			uwsgi_py_dict_del(spool_dict, "priority");
+		}
+	}
+
+	PyObject *pyat = uwsgi_py_dict_get(spool_dict, "at");
+	if (pyat) {
+		if (PyInt_Check(pyat)) {
+			at = (time_t) PyInt_AsLong(pyat);
+			uwsgi_py_dict_del(spool_dict, "at");
+		}
+		else if (PyLong_Check(pyat)) {
+			at = (time_t) PyLong_AsLong(pyat);
+			uwsgi_py_dict_del(spool_dict, "at");
+		}
+		else if (PyFloat_Check(pyat)) {
+			at = (time_t) PyFloat_AsDouble(pyat);
+			uwsgi_py_dict_del(spool_dict, "at");
+		}
+	}
+
+	PyObject *pybody = uwsgi_py_dict_get(spool_dict, "body");
+	if (pybody) {
+		if (PyString_Check(pybody)) {
+			body = PyString_AsString(pybody);
+			body_len = PyString_Size(pybody);
+			uwsgi_py_dict_del(spool_dict, "body");
+		}
+	}
+
 	spool_vars = PyDict_Items(spool_dict);
 	if (!spool_vars) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
+	char *spool_buffer = uwsgi_malloc(UMAX16);
+
 	cur_buf = spool_buffer;
 
 	for (i = 0; i < PyList_Size(spool_vars); i++) {
@@ -1162,12 +1322,16 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 				key = PyTuple_GetItem(zero, 0);
 				val = PyTuple_GetItem(zero, 1);
 
+#ifdef UWSGI_DEBUG
+				uwsgi_log("ob_type %s %s\n", key->ob_type->tp_name, val->ob_type->tp_name);
+#endif
+
 				if (PyString_Check(key) && PyString_Check(val)) {
 
 
 					keysize = PyString_Size(key);
 					valsize = PyString_Size(val);
-					if (cur_buf + keysize + 2 + valsize + 2 <= spool_buffer + uwsgi.buffer_size) {
+					if (cur_buf + keysize + 2 + valsize + 2 <= spool_buffer + UMAX16) {
 
 #ifdef __BIG_ENDIAN__
 						keysize = uwsgi_swap16(keysize);
@@ -1192,37 +1356,54 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 					}
 					else {
 						Py_DECREF(zero);
-						Py_INCREF(Py_None);
-						return Py_None;
+						free(spool_buffer);	
+						return PyErr_Format(PyExc_ValueError, "spooler packet cannot be more than %d bytes", UMAX16);
 					}
 				}
 				else {
 					Py_DECREF(zero);
+					free(spool_buffer);
 					return PyErr_Format(PyExc_ValueError, "spooler callable dictionary must contains only strings");
 				}
 			}
 			else {
+				free(spool_buffer);
 				Py_DECREF(zero);
 				Py_INCREF(Py_None);
 				return Py_None;
 			}
 		}
 		else {
+			free(spool_buffer);
 			Py_INCREF(Py_None);
 			return Py_None;
 		}
 	}
 
-	i = spool_request(spool_filename, uwsgi.workers[0].requests + 1, wsgi_req->async_id, spool_buffer, cur_buf - spool_buffer);
+	if (numprio) {
+		priority = uwsgi_num2str(numprio);
+	} 
+	i = spool_request(spool_filename, uwsgi.workers[0].requests + 1, wsgi_req->async_id, spool_buffer, cur_buf - spool_buffer, priority, at, body, body_len);
+	if (priority) {
+		free(priority);
+	}
+		
+	free(spool_buffer);
 
 	Py_DECREF(spool_vars);
 
 	if (i > 0) {
-		Py_INCREF(Py_True);
-		return Py_True;
+		char *slash = uwsgi_get_last_char(spool_filename, '/');
+		if (slash) {
+			return PyString_FromString(slash+1);
+		}
+		return PyString_FromString(spool_filename);
 	}
-	Py_INCREF(Py_None);
-	return Py_None;
+	return PyErr_Format(PyExc_ValueError, "unable to spool job");
+}
+
+PyObject *py_uwsgi_spooler_pid(PyObject * self, PyObject * args) {
+	return PyInt_FromLong(uwsgi.shared->spooler_pid ? uwsgi.shared->spooler_pid : 0);
 }
 #endif
 
@@ -1235,7 +1416,7 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 	int managed;
 	struct pollfd *multipoll;
 	char *buffer;
-	struct uwsgi_header uh;
+
 	PyObject *arg_cluster;
 
 	PyObject *cluster_node;
@@ -1349,9 +1530,11 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 			goto megamulticlear;
 		}
 		else {
+			// TODO fix
+/*
 			for (i = 0; i < clen; i++) {
 				if (multipoll[i].revents & POLLIN) {
-					if (!uwsgi_parse_response(&multipoll[i], PyInt_AsLong(arg_timeout), &uh, &buffer[i], uwsgi_proto_uwsgi_parser)) {
+					if (!uwsgi_parse_packet(&multipoll[i], PyInt_AsLong(arg_timeout), &uh, &buffer[i], uwsgi_proto_uwsgi_parser)) {
 						goto megamulticlear;
 					}
 					else {
@@ -1364,6 +1547,7 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 					}
 				}
 			}
+*/
 		}
 	}
 
@@ -1555,7 +1739,6 @@ PyObject *uwsgi_Iter_next(PyObject * self) {
 				ui->has_cl = 1;
 				ui->size = uh.pktsize;
 				ui->sent = 0;
-				uwsgi_log("NEED TO READ %d\n", uh.pktsize);
 			}
 		}
 
@@ -2202,6 +2385,9 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 		uwsgi.workers[uwsgi.mywid].id = uwsgi.mywid;
 		// this field will be overwrite after each call
 		uwsgi.workers[uwsgi.mywid].pid = uwsgi.mypid;
+
+		// reset the random seed
+		uwsgi_python_reset_random_seed();
 		// TODO
 		// manage thread in grunt processes
 		Py_INCREF(Py_True);
@@ -2209,8 +2395,10 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 	}
 
 	// close connection on the worker
-	fclose(wsgi_req->async_post);
-	wsgi_req->fd_closed = 1;
+	if (PyTuple_Size(args) == 0) {
+		fclose(wsgi_req->async_post);
+		wsgi_req->fd_closed = 1;
+	}
 
       clear:
 	Py_INCREF(Py_None);
@@ -2219,10 +2407,16 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 
 #ifdef UWSGI_SPOOLER
 static PyMethodDef uwsgi_spooler_methods[] = {
+#ifdef PYTHREE
+	{"send_to_spooler", (PyCFunction) py_uwsgi_send_spool, METH_VARARGS | METH_KEYWORDS, ""},
+	{"spool", (PyCFunction) py_uwsgi_send_spool, METH_VARARGS | METH_KEYWORDS, ""},
+#else
 	{"send_to_spooler", (PyCFunction) py_uwsgi_send_spool, METH_KEYWORDS, ""},
 	{"spool", (PyCFunction) py_uwsgi_send_spool, METH_KEYWORDS, ""},
+#endif
 	{"set_spooler_frequency", py_uwsgi_spooler_freq, METH_VARARGS, ""},
 	{"spooler_jobs", py_uwsgi_spooler_jobs, METH_VARARGS, ""},
+	{"spooler_pid", py_uwsgi_spooler_pid, METH_VARARGS, ""},
 	{NULL, NULL},
 };
 #endif
@@ -2267,7 +2461,9 @@ PyObject *py_uwsgi_cluster_node_name(PyObject * self, PyObject * args) {
 	for (i = 0; i < MAX_CLUSTER_NODES; i++) {
 		ucn = &uwsgi.shared->nodes[i];
 		if (ucn->name[0] != 0) {
+#ifdef UWSGI_DEBUG
 			uwsgi_log("node_name: %s %s\n", node, ucn->name);
+#endif
 			if (!strcmp(ucn->name, node)) {
 				return PyString_FromString(ucn->nodename);
 			}
@@ -2338,7 +2534,6 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"load_plugin", py_uwsgi_load_plugin, METH_VARARGS, ""},
 	{"lock", py_uwsgi_lock, METH_VARARGS, ""},
 	{"unlock", py_uwsgi_unlock, METH_VARARGS, ""},
-	{"send", py_uwsgi_send, METH_VARARGS, ""},
 	{"cl", py_uwsgi_cl, METH_VARARGS, ""},
 
 	{"listen_queue", py_uwsgi_listen_queue, METH_VARARGS, ""},
@@ -2348,6 +2543,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"register_signal", py_uwsgi_register_signal, METH_VARARGS, ""},
 	{"signal", py_uwsgi_signal, METH_VARARGS, ""},
 	{"signal_wait", py_uwsgi_signal_wait, METH_VARARGS, ""},
+	{"signal_registered", py_uwsgi_signal_registered, METH_VARARGS, ""},
 	{"signal_received", py_uwsgi_signal_received, METH_VARARGS, ""},
 	{"add_file_monitor", py_uwsgi_add_file_monitor, METH_VARARGS, ""},
 	{"add_timer", py_uwsgi_add_timer, METH_VARARGS, ""},
@@ -2394,6 +2590,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 	{"fcgi", py_uwsgi_fcgi, METH_VARARGS, ""},
 
 	{"parsefile", py_uwsgi_parse_file, METH_VARARGS, ""},
+	{"embedded_data", py_uwsgi_embedded_data, METH_VARARGS, ""},
 	//{"call_hook", py_uwsgi_call_hook, METH_VARARGS, ""},
 
 	{NULL, NULL},
@@ -2491,6 +2688,7 @@ PyObject *py_uwsgi_cache_exists(PyObject * self, PyObject * args) {
 	}
 	
 	if (remote && strlen(remote) > 0) {
+		// TODO FIX THIS !!!
 		uwsgi_simple_message_string(remote, 111, 0, key, keylen, buffer, &valsize, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
 		if (valsize > 0) {
 			Py_INCREF(Py_True);
@@ -2653,6 +2851,7 @@ PyObject *py_uwsgi_cache_get(PyObject * self, PyObject * args) {
 
 	char *key;
 	uint64_t valsize;
+	uint16_t valsize16;
 	Py_ssize_t keylen = 0;
 	char *value = NULL;
 	char *remote = NULL;
@@ -2668,8 +2867,8 @@ PyObject *py_uwsgi_cache_get(PyObject * self, PyObject * args) {
 	}
 
 	if (remote && strlen(remote) > 0) {
-		//uwsgi_simple_message_string(remote, 111, 0, key, keylen, buffer, &valsize, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
-		if (valsize > 0) {
+		uwsgi_simple_message_string(remote, 111, 0, key, keylen, buffer, &valsize16, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+		if (valsize16 > 0) {
 			value = buffer;
 		}
 	}
@@ -2734,13 +2933,6 @@ void init_uwsgi_module_spooler(PyObject * current_uwsgi_module) {
 		exit(1);
 	}
 
-	spool_buffer = malloc(uwsgi.buffer_size);
-	if (!spool_buffer) {
-		uwsgi_error("malloc()");
-		exit(1);
-	}
-
-
 	for (uwsgi_function = uwsgi_spooler_methods; uwsgi_function->ml_name != NULL; uwsgi_function++) {
 		PyObject *func = PyCFunction_New(uwsgi_function, NULL);
 		PyDict_SetItemString(uwsgi_module_dict, uwsgi_function->ml_name, func);

plugins/python/uwsgi_python.h

@@ -13,6 +13,8 @@
 #define LONG_ARGS_PYARGV                LONG_ARGS_PYTHON_BASE + 3
 #define LONG_ARGS_PYMODULE_ALIAS        LONG_ARGS_PYTHON_BASE + 4
 #define LONG_ARGS_RELOAD_OS_ENV		LONG_ARGS_PYTHON_BASE + 5
+#define LONG_ARGS_PYIMPORT		LONG_ARGS_PYTHON_BASE + 6
+#define LONG_ARGS_POST_PYMODULE_ALIAS   LONG_ARGS_PYTHON_BASE + 7
 
 #if PY_MINOR_VERSION == 4 && PY_MAJOR_VERSION == 2
 #define Py_ssize_t ssize_t
@@ -60,10 +62,14 @@ PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t);
 #define	PyString_Concat		PyBytes_Concat
 #define	PyString_AsString	(char *) PyBytes_AsString
 #define PyFile_FromFile(A,B,C,D) PyFile_FromFd(fileno((A)), (B), (C), -1, NULL, NULL, NULL, 0)
+#define uwsgi_py_dict_get(a, b) PyDict_GetItem(a, PyBytes_FromString(b));
+#define uwsgi_py_dict_del(a, b) PyDict_DelItem(a, PyBytes_FromString(b));
 
 #else
 #define UWSGI_PYFROMSTRING(x) PyString_FromString(x)
 #define UWSGI_PYFROMSTRINGSIZE(x, y) PyString_FromStringAndSize(x, y)
+#define uwsgi_py_dict_get(a, b) PyDict_GetItemString(a, b)
+#define uwsgi_py_dict_del(a, b) PyDict_DelItemString(a, b)
 #endif
 
 #define LOADER_DYN              0
@@ -99,6 +105,8 @@ struct uwsgi_python {
 	char *test_module;
 
 	struct uwsgi_string_list *python_path;
+	struct uwsgi_string_list *import_list;
+	struct uwsgi_string_list *post_pymodule_alias;
 
 	PyObject *loader_dict;
 	PyObject* (*loaders[LOADER_MAX]) (void *);
@@ -221,3 +229,11 @@ void threaded_reset_ts(struct wsgi_request *, struct uwsgi_app *);
 void simple_reset_ts(struct wsgi_request *, struct uwsgi_app *);
 
 int uwsgi_python_profiler_call(PyObject *, PyFrameObject *, int, PyObject *);
+
+void uwsgi_python_reset_random_seed(void);
+
+#ifdef __linux__
+#ifndef PYTHREE
+int uwsgi_init_symbol_import(void);
+#endif
+#endif

plugins/python/uwsgiplugin.py

@@ -3,7 +3,7 @@ import os,sys
 from distutils import sysconfig
 
 NAME='python'
-GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler']
+GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter']
 
 CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True) ] 
 LDFLAGS = []

plugins/python/wsgi_handlers.c

@@ -44,8 +44,9 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
 				return res;
 			}
 		}
+		res = PyString_FromStringAndSize(ptr + self->readline_pos, self->readline_size - self->readline_pos);
 		self->readline_pos = 0;
-		return PyString_FromStringAndSize(ptr + self->readline_pos, self->readline_size - self->readline_pos);
+		return res;
 	}
 
 
@@ -74,7 +75,7 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
 
 	for(i=0;i<(size_t)rlen;i++) {
 		if (self->readline[i] == '\n') {
-			res = PyString_FromStringAndSize(self->readline, i);
+			res = PyString_FromStringAndSize(self->readline, i+1);
 			self->readline_pos+= i+1;
 			if (self->readline_pos >= self->readline_size) self->readline_pos = 0;
 			return res;

plugins/python/wsgi_headers.c

@@ -13,7 +13,6 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 	PyObject *headers, *head;
 	PyObject *h_key, *h_value;
 	int i, j;
-	struct uwsgi_header uh;
 	PyObject *exc_info = NULL;
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -70,10 +69,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		}
 
 		wsgi_req->hvec[0].iov_len = wsgi_req->protocol_len;
-		uh.pktsize = wsgi_req->hvec[0].iov_len;
 		wsgi_req->hvec[1].iov_base = " ";
 		wsgi_req->hvec[1].iov_len = 1;
-		uh.pktsize += wsgi_req->hvec[1].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[2].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(head));
 		wsgi_req->hvec[2].iov_len = strlen(wsgi_req->hvec[2].iov_base);
@@ -81,18 +78,15 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[2].iov_base = PyString_AsString(head);
 		wsgi_req->hvec[2].iov_len = PyString_Size(head);
 #endif
-		uh.pktsize += wsgi_req->hvec[2].iov_len;
 		wsgi_req->status = uwsgi_str3_num(wsgi_req->hvec[2].iov_base);
 		wsgi_req->hvec[3].iov_base = nl;
 		wsgi_req->hvec[3].iov_len = NL_SIZE;
-		uh.pktsize += wsgi_req->hvec[3].iov_len;
 	}
 	else {
 		// drop http status on cgi mode
 		base = 3;
 		wsgi_req->hvec[0].iov_base = "Status: ";
 		wsgi_req->hvec[0].iov_len = 8;
-		uh.pktsize = wsgi_req->hvec[0].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[1].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(head));
 		wsgi_req->hvec[1].iov_len = strlen(wsgi_req->hvec[1].iov_base);
@@ -100,11 +94,9 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[1].iov_base = PyString_AsString(head);
 		wsgi_req->hvec[1].iov_len = PyString_Size(head);
 #endif
-		uh.pktsize += wsgi_req->hvec[1].iov_len;
 		wsgi_req->status = uwsgi_str3_num(wsgi_req->hvec[1].iov_base);
 		wsgi_req->hvec[2].iov_base = nl;
 		wsgi_req->hvec[2].iov_len = NL_SIZE;
-		uh.pktsize += wsgi_req->hvec[2].iov_len;
 	}
 
 	headers = PyTuple_GetItem(args, 1);
@@ -146,10 +138,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[j].iov_base = PyString_AsString(h_key);
 		wsgi_req->hvec[j].iov_len = PyString_Size(h_key);
 #endif
-		uh.pktsize += wsgi_req->hvec[j].iov_len;
 		wsgi_req->hvec[j + 1].iov_base = h_sep;
 		wsgi_req->hvec[j + 1].iov_len = H_SEP_SIZE;
-		uh.pktsize += wsgi_req->hvec[j+1].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[j + 2].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(h_value));
 		wsgi_req->hvec[j + 2].iov_len = strlen(wsgi_req->hvec[j + 2].iov_base);
@@ -158,29 +148,63 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[j + 2].iov_len = PyString_Size(h_value);
 #endif
 
-		uh.pktsize += wsgi_req->hvec[j+2].iov_len;
 
 		wsgi_req->hvec[j + 3].iov_base = nl;
 		wsgi_req->hvec[j + 3].iov_len = NL_SIZE;
 
-		uh.pktsize += wsgi_req->hvec[j+3].iov_len;
 		//uwsgi_log( "%.*s: %.*s\n", wsgi_req->hvec[j].iov_len, (char *)wsgi_req->hvec[j].iov_base, wsgi_req->hvec[j+2].iov_len, (char *) wsgi_req->hvec[j+2].iov_base);
 	}
 
+	j = (i * 4) + base;
+
+	struct uwsgi_string_list *ah = uwsgi.additional_headers;
+	while(ah) {
+		if (wsgi_req->header_cnt+1 <= uwsgi.max_vars) {
+			wsgi_req->header_cnt++;
+			wsgi_req->hvec[j].iov_base = ah->value;
+        		wsgi_req->hvec[j].iov_len = ah->len;
+			j++;
+			wsgi_req->hvec[j].iov_base = nl;
+        		wsgi_req->hvec[j].iov_len = NL_SIZE;
+			j++;
+			ah = ah->next;
+		}
+		else {
+			uwsgi_log("no more space in iovec. consider increasing max-vars...\n");
+			break;
+		}
+	}
+
 
 	// \r\n
-	j = (i * 4) + base;
 	wsgi_req->hvec[j].iov_base = nl;
 	wsgi_req->hvec[j].iov_len = NL_SIZE;
 
-	uh.pktsize += wsgi_req->hvec[j].iov_len;
-
+#ifdef __sun__
+	int remains = j + 1;
+	int iov_size;
+	struct iovec* iov_ptr = wsgi_req->hvec;
+	ssize_t iov_ret;
+	while(remains) {
+		iov_size = UMIN(remains, IOV_MAX);
+		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;
+	}
+#else
 	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);
 	Py_INCREF(up.wsgi_writeout);

plugins/python/wsgi_subhandler.c

@@ -96,6 +96,10 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 		Py_DECREF(zero);
 	}
 
+	zero = PyString_FromString(uwsgi.hostname);
+	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", zero);
+	Py_DECREF(zero);
+
 
 #ifdef UWSGI_ROUTING
 	uwsgi_log("routing %d routes %d\n", uwsgi.routing, uwsgi.nroutes);

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'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_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'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_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'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_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'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.7-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/rack/rack_plugin.c

@@ -134,6 +134,7 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 	
 	if (RARRAY_LEN(args) == 0) {
 		chunk = rb_str_new(wsgi_req->post_buffering_buf+wsgi_req->buf_pos, wsgi_req->post_cl-wsgi_req->buf_pos);
+		wsgi_req->buf_pos += (wsgi_req->post_cl-wsgi_req->buf_pos);
 		return chunk;
 	}
 	else if (RARRAY_LEN(args) > 0) {
@@ -141,11 +142,12 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 		if (wsgi_req->buf_pos+chunk_size > wsgi_req->post_cl) {
 			chunk_size = wsgi_req->post_cl-wsgi_req->buf_pos;
 		}
-		wsgi_req->buf_pos+=chunk_size;
 		if (RARRAY_LEN(args) > 1) {
 			rb_str_cat(RARRAY_PTR(args)[1], wsgi_req->post_buffering_buf+wsgi_req->buf_pos, chunk_size);
+			wsgi_req->buf_pos+=chunk_size;
 			return RARRAY_PTR(args)[1];
 		}
+		wsgi_req->buf_pos+=chunk_size;
 		return rb_str_new(wsgi_req->post_buffering_buf+wsgi_req->buf_pos, chunk_size);
 	}
 

plugins/rpc/rpc_plugin.c

@@ -5,9 +5,8 @@ extern struct uwsgi_server uwsgi;
 
 int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 
-	char *argv[0xff];
-	uint8_t argc;
-	int i;
+	char *argv[256];
+	uint8_t argc = 0xff;
 
 	/* Standard RPC request */
         if (!wsgi_req->uh.pktsize) {
@@ -15,17 +14,25 @@ int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
                 return -1;
         }
 
-	uwsgi_log("parsing array\n");
+	/*
+	for(argc=0;argc<wsgi_req->uh.pktsize;argc++) {
+		uwsgi_log("rpc: %c\n", wsgi_req->buffer[argc]);
+	}
+	*/
+
+#ifdef UWSGI_DEBUG
+	uwsgi_log("RPC pktsize %d\n", wsgi_req->uh.pktsize);
+#endif
+
 	if (uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh.pktsize, argv, &argc)) {
                 uwsgi_log("Invalid RPC request. skip.\n");
                 return -1;
 	}
-	uwsgi_log("done\n");
-	
-	for(i=0;i<argc;i++) {
-		uwsgi_log("arg %d %s\n", i, argv[i]);
-	}
 
+#ifdef UWSGI_DEBUG
+	uwsgi_log("RPC args %d\n", argc-1);
+#endif
+	
 	wsgi_req->uh.pktsize = uwsgi_rpc(argv[0], argc-1, argv+1, wsgi_req->buffer);
 
 	if (wsgi_req->uh.modifier2 == 0) {

proto/base.c

@@ -17,7 +17,7 @@ uint16_t proto_base_add_uwsgi_header(struct wsgi_request *wsgi_req, char *key, u
 			key[i] = '_';
 		}
 		else {
-			key[i] = toupper(key[i]);
+			key[i] = toupper((int)key[i]);
 		}
 	}
 
@@ -90,6 +90,7 @@ uint16_t proto_base_add_uwsgi_var(struct wsgi_request * wsgi_req, char *key, uin
 
 int uwsgi_proto_base_accept(struct wsgi_request *wsgi_req, int fd) {
 
+	wsgi_req->c_len = sizeof(struct sockaddr_un);
 	return accept(fd, (struct sockaddr *) &wsgi_req->c_addr, (socklen_t *) & wsgi_req->c_len);
 }
 

proto/fastcgi.c

@@ -254,7 +254,7 @@ ssize_t uwsgi_proto_fastcgi_sendfile(struct wsgi_request *wsgi_req) {
 			return -1;
 		}
 		len = read(wsgi_req->sendfile_fd, buf, ntohs(fr.cl));
-		if (len != ntohs(fr.cl)) {
+		if (len != (ssize_t) ntohs(fr.cl)) {
 			uwsgi_error("read()");
 			return -1;
 		}
@@ -270,7 +270,7 @@ ssize_t uwsgi_proto_fastcgi_sendfile(struct wsgi_request *wsgi_req) {
 			return -1;
 		}
 		len = read(wsgi_req->sendfile_fd, buf, ntohs(fr.cl));
-		if (len != ntohs(fr.cl)) {
+		if (len != (ssize_t) ntohs(fr.cl)) {
 			uwsgi_error("read()");
 			return -1;
 		}

proto/http.c

@@ -89,6 +89,8 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	char *ptr = wsgi_req->proto_parser_buf;
 	char *base = ptr;
 	char *query_string = NULL;
+	char ip[INET_ADDRSTRLEN+1];
+	struct sockaddr_in *http_sin = (struct sockaddr_in *) &wsgi_req->c_addr;
 
 	// REQUEST_METHOD 
 	while (ptr < watermark) {
@@ -146,15 +148,14 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	// SERVER_PORT
 	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "3031", 4);
 
-	/*
-	   // REMOTE_ADDR
-	   if (inet_ntop(AF_INET, &h_session->ip_addr, h_session->ip, INET_ADDRSTRLEN)) {
-	   h_session->uh.pktsize += proto_base_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, "REMOTE_ADDR", 11, h_session->ip, strlen(h_session->ip));
-	   }
-	   else {
-	   uwsgi_error("inet_ntop()");
-	   }
-	 */
+	// REMOTE_ADDR
+	memset(ip, 0, INET_ADDRSTRLEN+1);
+	if (inet_ntop(AF_INET, (void *) &http_sin->sin_addr.s_addr, ip, INET_ADDRSTRLEN)) {
+		wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, ip, strlen(ip));
+	}
+	else {
+		uwsgi_error("inet_ntop()");
+	}
 
 	//HEADERS
 	base = ptr;

proto/uwsgi.c

@@ -56,7 +56,7 @@ int uwsgi_proto_uwsgi_parser(struct wsgi_request *wsgi_req) {
 
 			/* check for max buffer size */
 			if (wsgi_req->uh.pktsize > uwsgi.buffer_size) {
-				uwsgi_log("invalid request block size: %d...skip\n", wsgi_req->uh.pktsize);
+				uwsgi_log("invalid request block size: %d (max %d)...skip\n", wsgi_req->uh.pktsize, uwsgi.buffer_size);
 				return -1;
 			}
 
@@ -84,6 +84,9 @@ int uwsgi_proto_uwsgi_parser(struct wsgi_request *wsgi_req) {
 				return UWSGI_OK;
 #endif
 
+			if (uwsgi.no_fd_passing)
+				return UWSGI_OK;
+
 			cmsg = CMSG_FIRSTHDR(&wsgi_req->msg);
 			while (cmsg != NULL) {
 				if (cmsg->cmsg_len == CMSG_LEN(sizeof(int)) && cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type && SCM_RIGHTS) {

protocol.c

@@ -173,6 +173,8 @@ ssize_t send_udp_message(uint8_t modifier1, char *host, char *message, uint16_t
 	}
 	close(fd);
 
+	udp_port[0] = ':';
+
 	return ret;
 	
 }
@@ -339,7 +341,7 @@ ssize_t uwsgi_send_message(int fd, uint8_t modifier1, uint8_t modifier2, char *m
 }
 
 
-int uwsgi_parse_response(struct pollfd *upoll, int timeout, struct uwsgi_header *uh, char *buffer, int (*socket_proto)(struct wsgi_request *)) {
+int uwsgi_parse_packet(struct wsgi_request *wsgi_req, int timeout) {
 	int rlen;
 	int status = UWSGI_AGAIN;
 
@@ -347,7 +349,7 @@ int uwsgi_parse_response(struct pollfd *upoll, int timeout, struct uwsgi_header
 		timeout = 1;
 
 	while(status == UWSGI_AGAIN) {
-		rlen = poll(upoll, 1, timeout * 1000);
+		rlen = poll(&wsgi_req->poll, 1, timeout * 1000);
 		if (rlen < 0) {
 			uwsgi_error("poll()");
 			exit(1);
@@ -357,7 +359,12 @@ int uwsgi_parse_response(struct pollfd *upoll, int timeout, struct uwsgi_header
 			//close(upoll->fd);
 			return 0;
 		}
-		status = socket_proto((struct wsgi_request *) uh);
+		if (wsgi_req->socket) {
+			status = wsgi_req->socket->proto(wsgi_req);
+		}
+		else {
+			status = uwsgi_proto_uwsgi_parser(wsgi_req);
+		}
 		if (status < 0) {
 			uwsgi_log("error parsing request\n");
 			//close(upoll->fd);
@@ -393,6 +400,7 @@ int uwsgi_parse_array(char *buffer, uint16_t size, char **argv, uint8_t *argc) {
                         if (ptrbuf + strsize <= bufferend) {
                                 // item
 				argv[*argc] = uwsgi_cheap_string(ptrbuf, strsize);
+				uwsgi_log("arg %s\n", argv[*argc]);
                                 ptrbuf += strsize;
 				*argc = *argc + 1;
 			}
@@ -754,7 +762,7 @@ int uwsgi_ping_node(int node, struct wsgi_request *wsgi_req) {
 	}
 
 	uwsgi_poll.events = POLLIN;
-	if (!uwsgi_parse_response(&uwsgi_poll, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], (struct uwsgi_header *) wsgi_req, wsgi_req->buffer, uwsgi_proto_uwsgi_parser)) {
+	if (!uwsgi_parse_packet(wsgi_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT])) {
 		return -1;
 	}
 
@@ -819,7 +827,9 @@ int uwsgi_get_dgram(int fd, struct wsgi_request *wsgi_req) {
                 return -1;
         }
 
-	uwsgi_log("recevied request from %s\n", inet_ntoa(sin.sin_addr));
+#ifdef UWSGI_DEBUG
+	uwsgi_log("received request from %s\n", inet_ntoa(sin.sin_addr));
+#endif
 
         if (rlen < 4) {
                 uwsgi_log("invalid uwsgi packet\n");
@@ -843,7 +853,9 @@ int uwsgi_get_dgram(int fd, struct wsgi_request *wsgi_req) {
 
 	wsgi_req->buffer = buffer+4;
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("request received %d %d\n", wsgi_req->uh.modifier1, wsgi_req->uh.modifier2);
+#endif
 
 	return 0;
 
@@ -909,20 +921,27 @@ int uwsgi_hooked_parse_dict_dgram(int fd, char *buffer, size_t len, uint8_t modi
 		return -1;
 	}
 
-	uwsgi_log("recevied request from %s\n", inet_ntoa(sin.sin_addr));
 
+#ifdef UWSGI_DEBUG
 	uwsgi_log("RLEN: %d\n", rlen);
+#endif
 
 	// check for valid dict 4(header) 2(non-zero key)+1 2(value)
 	if (rlen < (4+2+1+2)) {
+#ifdef UWSGI_DEBUG
 		uwsgi_log("invalid uwsgi dictionary\n");
+#endif
 		return -1;
 	}
+
+	uwsgi_log("received message from %s\n", inet_ntoa(sin.sin_addr));
 	
 	uh = (struct uwsgi_header *) buffer;
 
 	if (uh->modifier1 != modifier1 || uh->modifier2 != modifier2) {
+#ifdef UWSGI_DEBUG
 		uwsgi_log("invalid uwsgi dictionary received, modifier1: %d modifier2: %d\n", uh->modifier1, uh->modifier2);
+#endif
 		return -1;
 	}
 
@@ -942,7 +961,9 @@ int uwsgi_hooked_parse_dict_dgram(int fd, char *buffer, size_t len, uint8_t modi
 	}
 
 	
+#ifdef UWSGI_DEBUG
 	uwsgi_log("%p %p %d\n", ptrbuf, bufferend, bufferend-ptrbuf);
+#endif
 
 	uwsgi_hooked_parse(ptrbuf, bufferend-ptrbuf, hook, data);
 
@@ -1096,8 +1117,7 @@ uint16_t fcgi_get_record(int fd, char *buf) {
 
 char *uwsgi_simple_message_string(char *socket_name, uint8_t modifier1, uint8_t modifier2, char *what, uint16_t what_len, char *buffer, uint16_t *response_len, int timeout) {
 
-	struct uwsgi_header uh;
-	struct pollfd upoll;
+	struct wsgi_request msg_req;
 
 	int fd = uwsgi_connect(socket_name, timeout, 0);
 
@@ -1112,19 +1132,22 @@ char *uwsgi_simple_message_string(char *socket_name, uint8_t modifier1, uint8_t
 		return NULL;
 	}
 
-	upoll.fd = fd;
-	upoll.events = POLLIN;
+	memset(&msg_req, 0, sizeof(struct wsgi_request));
+	msg_req.poll.fd = fd;
+	msg_req.poll.events = POLLIN;
+	msg_req.buffer = buffer;
 
 	if (buffer) {
-		if (!uwsgi_parse_response(&upoll, timeout, &uh, buffer, uwsgi_proto_uwsgi_parser)) {
+		if (!uwsgi_parse_packet(&msg_req, timeout)) {
 			close(fd);
 			if (response_len) *response_len = 0;
 			return NULL;
 		}
+
+		if (response_len) *response_len = msg_req.uh.pktsize;
 	}
 
 	close(fd);
-	if (response_len) *response_len = uh.pktsize;
 	return buffer;
 }
 
@@ -1242,7 +1265,16 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
                         if (st.st_mtime <= ims) {
                                 wsgi_req->status = 304;
                                 wsgi_req->headers_size = wsgi_req->socket->proto_write_header(wsgi_req, wsgi_req->protocol, wsgi_req->protocol_len);
-                                wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, " 304 Not Modified\r\n\r\n", 21);
+                                wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, " 304 Not Modified\r\n", 19);
+
+				struct uwsgi_string_list *ah = uwsgi.additional_headers;
+				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);
+					ah = ah->next;
+				}
+
+				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2);
                                 return 0;
                         }
                 }
@@ -1256,6 +1288,13 @@ 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, wsgi_req->protocol, wsgi_req->protocol_len);
                         wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, " 200 OK\r\n", 9);
 
+			struct uwsgi_string_list *ah = uwsgi.additional_headers;
+			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);
+				ah = ah->next;
+			}
+
 			if (uwsgi.file_serve_mode == 1) {
                                 wsgi_req->header_cnt = 2;
 				wsgi_req->headers_size += wsgi_req->socket->proto_write_header(wsgi_req, "X-Accel-Redirect: ", 18);
@@ -1298,3 +1337,17 @@ int uwsgi_file_serve(struct wsgi_request *wsgi_req, char *document_root, uint16_
 
 }
 
+char *uwsgi_get_var(struct wsgi_request *wsgi_req, char *key, uint16_t *len) {
+
+	int i;
+	*len = 0;
+	for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+		if (!uwsgi_strncmp(key, strlen(key), wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len)) {
+			*len = wsgi_req->hvec[i + 1].iov_len;
+			return wsgi_req->hvec[i + 1].iov_base;
+		}
+        }
+
+	return NULL;
+
+}

rpc.c

@@ -7,6 +7,11 @@ int uwsgi_register_rpc(char *name, uint8_t modifier1, uint8_t args, void *func)
 	struct uwsgi_rpc *urpc;
 	int ret = -1;
 
+	if (uwsgi.mywid != 0) {
+		uwsgi_log("you can register RPC functions only in the master\n");
+		return -1;
+	}
+
 	uwsgi_lock(uwsgi.rpc_table_lock);
 
 	if (uwsgi.shared->rpc_count < MAX_RPC) {

runningthread.py

@@ -0,0 +1,14 @@
+from threading import Thread
+import time
+
+def mess():
+    while True:
+        for i in xrange(0, 100):
+            print(i)
+            time.sleep(0.1)
+
+t = Thread(target=mess)
+t.daemon = True
+t.start()
+
+print("thread started")

sendfile.c

@@ -76,7 +76,9 @@ ssize_t uwsgi_do_sendfile(int sockfd, int filefd, size_t filesize, size_t chunk,
 	}
 
 	if (sf_ret) {
+#ifdef UWSGI_DEBUG
 		uwsgi_log("sf_len = %d\n", sf_len);
+#endif
 		uwsgi_error("sendfile()");
 		return 0;
 	}

signal.c

@@ -11,10 +11,18 @@ int uwsgi_signal_handler(uint8_t sig) {
 	if (!uwsgi.p[use->modifier1]->signal_handler) {
 		return -1;
 	}	
-	
+
 	return uwsgi.p[use->modifier1]->signal_handler(sig, use->handler);
 }
 
+int uwsgi_signal_registered(uint8_t sig) {
+
+	if (uwsgi.shared->signal_table[sig].handler != NULL)
+		return 1;
+
+	return 0;
+}
+
 int uwsgi_register_signal(uint8_t sig, char *receiver, void *handler, uint8_t modifier1) {
 
 	struct uwsgi_signal_entry *use = NULL;
@@ -146,6 +154,7 @@ int uwsgi_signal_add_rb_timer(uint8_t sig, int secs, int iterations) {
 
 void uwsgi_route_signal(uint8_t sig) {
 
+	int i;
 	struct uwsgi_signal_entry *use = &ushared->signal_table[sig];
 	// send to first available worker
 	if (use->receiver[0] == 0 || !strcmp(use->receiver, "worker") || !strcmp(use->receiver, "worker0")) {
@@ -156,21 +165,38 @@ void uwsgi_route_signal(uint8_t sig) {
 	}
 	// send to all workers
 	else if (!strcmp(use->receiver, "workers")) {
-		if (write(ushared->worker_signal_pipe[0], &sig, 1) != 1) {
-			uwsgi_error("write()");
-			uwsgi_log("could not deliver signal %d to workers pool\n", sig);
+		for(i=1;i<=uwsgi.numproc;i++) {
+			if (write(uwsgi.signal_pipe[i][0], &sig, 1) != 1) {
+				uwsgi_error("write()");
+				uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
+			}
 		}
 	}
+	// route to specific worker
+	else if (!strncmp(use->receiver, "worker", 6)) {
+		i = atoi(use->receiver+6);
+		if (i > uwsgi.numproc) {
+			uwsgi_log("invalid signal target: %s\n", use->receiver);
+		}
+		if (write(uwsgi.signal_pipe[i][0], &sig, 1) != 1) {
+                        uwsgi_error("write()");
+                	uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
+                }
+	}
 	// route to subscribed
 	else if (!strcmp(use->receiver, "subscribed")) {
 	}
+	// route to spooler
+	else if (!strcmp(use->receiver, "spooler")) {
+		if (ushared->worker_signal_pipe[0] != -1) {
+			if (write(ushared->spooler_signal_pipe[0], &sig, 1) != 1) {
+                        	uwsgi_error("write()");
+                        	uwsgi_log("could not deliver signal %d to the spooler\n", sig);
+                	}
+		}
+	}
 	else {
 		// unregistered signal, sending it to all the workers
-		uwsgi_log("^^^ ROUTING UNREGISTERED SIGNAL ^^^\n");
-		if (write(ushared->worker_signal_pipe[0], &sig, 1) != 1) {
-                        uwsgi_error("write()");
-                        uwsgi_log("could not deliver signal %d to workers pool\n", sig);
-                }
-
+		uwsgi_log("^^^ UNSUPPORTED SIGNAL TARGET: %s ^^^\n", use->receiver);
 	}
 }

sigwait.py

@@ -0,0 +1,28 @@
+import uwsgi
+from uwsgidecorators import *
+
+@signal(17, target='workers')
+def hello(signum):
+    print("I AM THE WORKER %d" % uwsgi.worker_id())
+
+@signal(30, target='worker2')
+def hello2(signum):
+    print("I AM THE WORKER 2")
+
+@postfork
+def wait_for_signal():
+    if uwsgi.worker_id() != 2:
+        print("waiting for a signal...")
+        uwsgi.signal_wait()
+        print("signal %d received" % uwsgi.signal_received())
+
+
+def application(e, s):
+    s('200 OK', [('Content-Type', 'text/html')])
+    if e['PATH_INFO'] == '/30':
+        uwsgi.signal(30)
+        uwsgi.signal(100)
+    else:
+        uwsgi.signal(17)
+    return "Signal raised"
+   

socket.c

@@ -6,6 +6,7 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 
 	int serverfd;
 	struct sockaddr_un *uws_addr;
+	socklen_t len;
 
 	// leave 1 byte for abstract namespace (108 linux -> 104 bsd/mac)
 	if (strlen(socket_name) > 102) {
@@ -13,6 +14,13 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 		uwsgi_nuclear_blast();
 	}
 
+	if (socket_name[0] == '@') {
+		abstract_socket = 1;
+	}
+	else if (strlen(socket_name) > 1 && socket_name[0] == '\\' && socket_name[1] == '0') {
+		abstract_socket = 1;
+	}
+
 	uws_addr = malloc(sizeof(struct sockaddr_un));
 	if (uws_addr == NULL) {
 		uwsgi_error("malloc()");
@@ -36,12 +44,28 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 	}
 
 	uws_addr->sun_family = AF_UNIX;
-	memcpy(uws_addr->sun_path + abstract_socket, socket_name, 102);
+	if (socket_name[0] == '@') {
+		memcpy(uws_addr->sun_path + abstract_socket, socket_name+1, UMIN(strlen(socket_name+1), 101));
+		len = strlen(socket_name) + 1;
+	}
+	else if (strlen(socket_name) > 1 && socket_name[0] == '\\' && socket_name[1] == '0') {
+		memcpy(uws_addr->sun_path + abstract_socket, socket_name+2, UMIN(strlen(socket_name+2), 101));
+		len = strlen(socket_name+1) + 1;
+		
+	}
+	else if (abstract_socket) {
+		memcpy(uws_addr->sun_path + 1, socket_name, UMIN(strlen(socket_name), 101));
+		len = strlen(socket_name)+1;
+	}
+	else {
+		memcpy(uws_addr->sun_path + abstract_socket, socket_name, UMIN(strlen(socket_name), 102));
+		len = strlen(socket_name);
+	}
 
 #ifdef __HAIKU__
 	if (bind(serverfd, (struct sockaddr *) uws_addr, sizeof(struct sockaddr_un))) {
 #else
-	if (bind(serverfd, (struct sockaddr *) uws_addr, strlen(socket_name) + abstract_socket + ((void *) uws_addr->sun_path - (void *) uws_addr)) != 0) {
+	if (bind(serverfd, (struct sockaddr *) uws_addr, len + ((void *) uws_addr->sun_path - (void *) uws_addr)) != 0) {
 #endif
 		uwsgi_error("bind()");
 		uwsgi_nuclear_blast();
@@ -251,11 +275,23 @@ int connect_to_unix(char *socket_name, int timeout, int async) {
 
 	struct pollfd uwsgi_poll;
 	struct sockaddr_un uws_addr;
+	socklen_t un_size = sizeof(struct sockaddr_un);
 
 	memset(&uws_addr, 0, sizeof(struct sockaddr_un));
 
 	uws_addr.sun_family = AF_UNIX;
-	memcpy(uws_addr.sun_path, socket_name, 102);
+
+	if (socket_name[0] == '@'){
+		un_size = sizeof(uws_addr.sun_family) + strlen(socket_name) + 1;
+		memcpy(uws_addr.sun_path+1, socket_name+1, UMIN(strlen(socket_name+1), 101));
+	}
+	else if (strlen(socket_name) > 1 && socket_name[0] == '\\' && socket_name[1] == '0') {
+		un_size = sizeof(uws_addr.sun_family) + strlen(socket_name+1) + 1;
+		memcpy(uws_addr.sun_path+1, socket_name+2, UMIN(strlen(socket_name+2), 101));
+	}
+	else {
+		memcpy(uws_addr.sun_path, socket_name, UMIN(strlen(socket_name), 102));
+	}
 
 	uwsgi_poll.fd = socket(AF_UNIX, SOCK_STREAM, 0);
 	if (uwsgi_poll.fd < 0) {
@@ -265,7 +301,7 @@ int connect_to_unix(char *socket_name, int timeout, int async) {
 
 	uwsgi_poll.events = POLLIN;
 
-	if (timed_connect(&uwsgi_poll, (const struct sockaddr *) &uws_addr, sizeof(struct sockaddr_un), timeout, async)) {
+	if (timed_connect(&uwsgi_poll, (const struct sockaddr *) &uws_addr, un_size, timeout, async)) {
 		uwsgi_error("connect()");
 		close(uwsgi_poll.fd);
 		return -1;
@@ -316,7 +352,6 @@ char *generate_socket_name(char *socket_name) {
 
 	char *asterisk = strchr(socket_name, '*');
 
-	char *new_socket;
 	char *tcp_port;
 	int i;
 	char *ptr = socket_name;
@@ -345,7 +380,14 @@ char *generate_socket_name(char *socket_name) {
 
 	if (asterisk) {
 
+#ifndef UWSGI_HAS_IFADDRS
+		uwsgi_log("your system does not support ifaddrs subsystem\n");
+#else
+		char *new_socket;
+
+#ifdef UWSGI_DEBUG
 		uwsgi_log("generate_socket_name(%s)\n", socket_name);
+#endif
 		// get all the AF_INET addresses available
 		struct ifaddrs *ifap = NULL, *ifa, *ifaf;
 		if (getifaddrs(&ifap)) {
@@ -356,7 +398,9 @@ char *generate_socket_name(char *socket_name) {
 		// here socket_name will be truncated
 		asterisk[0] = 0;
 
+#ifdef UWSGI_DEBUG
 		uwsgi_log("asterisk found\n");
+#endif
 
 		char new_addr[16];
 		struct sockaddr_in *sin;
@@ -381,24 +425,69 @@ char *generate_socket_name(char *socket_name) {
 		}
 
 		uwsgi_log("unable to find avalid socket address\n");
+#endif
 		uwsgi_nuclear_blast();
 	}
 	return socket_name;
 }
 
+socklen_t socket_to_un_addr(char *socket_name, struct sockaddr_un *sun_addr) {
+
+	size_t len = strlen(socket_name);
+
+	if (len > 102) {
+		uwsgi_log("invalid UNIX socket address: %s\n", socket_name);
+		uwsgi_nuclear_blast();
+	}
+
+	memset(sun_addr, 0, sizeof(struct sockaddr_un));
+
+        sun_addr->sun_family = AF_UNIX;
+
+	// abstract socket
+        if (socket_name[0] == '@') {
+		memcpy(sun_addr->sun_path+1, socket_name+1, UMIN(len-1, 101));
+		len = strlen(socket_name) + 1;
+        }
+	else if (len > 1 && socket_name[0] == '\\' && socket_name[1] == '0') {
+		memcpy(sun_addr->sun_path+1, socket_name+2, UMIN(len-2, 101));
+		len = strlen(socket_name+1) + 1;
+	}
+        else {
+		memcpy(sun_addr->sun_path, socket_name, UMIN(len, 102));
+        }
+
+        return sizeof(sun_addr->sun_family)+len;
+}
+
+socklen_t socket_to_in_addr(char *socket_name, char *port, struct sockaddr_in *sin_addr) {
+
+	memset(sin_addr, 0, sizeof(struct sockaddr_in));
+	
+	sin_addr->sin_family = AF_INET;
+	if (port) {
+		port[0] = 0;
+		sin_addr->sin_port = htons(atoi(port + 1));
+	}
+
+	if (socket_name[0] == 0) {
+                sin_addr->sin_addr.s_addr = INADDR_ANY;
+        }
+        else {
+                sin_addr->sin_addr.s_addr = inet_addr(socket_name);
+        }
+
+	return sizeof(struct sockaddr_in);
+	
+}
+
 int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 
 	int serverfd;
 	struct sockaddr_in uws_addr;
 	int reuse = 1;
 
-	memset(&uws_addr, 0, sizeof(struct sockaddr_in));
-
-	uws_addr.sin_family = AF_INET;
-	if (tcp_port) {
-		tcp_port[0] = 0;
-		uws_addr.sin_port = htons(atoi(tcp_port + 1));
-	}
+	socket_to_in_addr(socket_name, tcp_port, &uws_addr);
 
 	serverfd = socket(AF_INET, SOCK_STREAM, 0);
 	if (serverfd < 0) {
@@ -406,19 +495,22 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		uwsgi_nuclear_blast();
 	}
 
-	if (socket_name[0] == 0) {
-		uws_addr.sin_addr.s_addr = INADDR_ANY;
-	}
-	else {
-		uws_addr.sin_addr.s_addr = inet_addr(socket_name);
-	}
-
-
 	if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse, sizeof(int)) < 0) {
 		uwsgi_error("setsockopt()");
 		uwsgi_nuclear_blast();
 	}
 
+	if (uwsgi.reuse_port) {
+#ifdef SO_REUSEPORT
+		if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEPORT, (const void *) &uwsgi.reuse_port, sizeof(int)) < 0) {
+			uwsgi_error("setsockopt()");
+			uwsgi_nuclear_blast();
+		}
+#else
+		uwsgi_log("!!! your system does not support SO_REUSEPORT !!!\n");
+#endif
+	}
+
 	if (!uwsgi.no_defer_accept) {
 
 #ifdef __linux__
@@ -552,6 +644,17 @@ int timed_connect(struct pollfd *fdpoll, const struct sockaddr *addr, int addr_s
 
 }
 
+int uwsgi_count_sockets(struct uwsgi_socket *uwsgi_sock) {
+
+	int count = 0;
+	while(uwsgi_sock) {
+		count++;
+		uwsgi_sock = uwsgi_sock->next;
+	}
+
+	return count;
+}
+
 int uwsgi_get_socket_num(struct uwsgi_socket *uwsgi_sock) {
 
 	int count = 0;
@@ -568,9 +671,53 @@ int uwsgi_get_socket_num(struct uwsgi_socket *uwsgi_sock) {
 	return -1;
 }
 
+int uwsgi_get_shared_socket_num(struct uwsgi_socket *uwsgi_sock) {
+
+        int count = 0;
+        struct uwsgi_socket *current_sock = uwsgi.shared_sockets;
+
+        while(current_sock) {
+                if (uwsgi_sock == current_sock) {
+                        return count;
+                }
+                count++;
+                current_sock = current_sock->next;
+        }
+
+        return -1;
+}
+
+
+struct uwsgi_socket *uwsgi_new_shared_socket(char *name) {
+
+        struct uwsgi_socket *uwsgi_sock = uwsgi.shared_sockets, *old_uwsgi_sock;
+
+        if (!uwsgi_sock) {
+                uwsgi.shared_sockets = uwsgi_malloc(sizeof(struct uwsgi_socket));
+                uwsgi_sock = uwsgi.shared_sockets;
+        }
+        else {
+                while(uwsgi_sock) {
+                        old_uwsgi_sock = uwsgi_sock;
+                        uwsgi_sock = uwsgi_sock->next;
+                }
+
+                uwsgi_sock = uwsgi_malloc(sizeof(struct uwsgi_socket));
+                old_uwsgi_sock->next = uwsgi_sock;
+        }
+
+        memset(uwsgi_sock, 0, sizeof(struct uwsgi_socket));
+        uwsgi_sock->name = name;
+
+        return uwsgi_sock;
+}
+
+
 struct uwsgi_socket *uwsgi_new_socket(char *name) {
 
 	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets, *old_uwsgi_sock;
+	struct sockaddr_in sin;
+	socklen_t socket_type_len;
 
 	if (!uwsgi_sock) {
 		uwsgi.sockets = uwsgi_malloc(sizeof(struct uwsgi_socket));
@@ -588,6 +735,31 @@ struct uwsgi_socket *uwsgi_new_socket(char *name) {
 
 	memset(uwsgi_sock, 0, sizeof(struct uwsgi_socket)); 
 	uwsgi_sock->name = name;
+
+	if (!name) return uwsgi_sock;
+
+	char *tcp_port = strchr(name, ':');
+	if (tcp_port) {
+		// INET socket, check for 0 port
+		if (tcp_port[1] == 0 || tcp_port[1] == '0') {
+			uwsgi_sock->fd = bind_to_tcp(name, uwsgi.listen_queue, tcp_port);
+                        uwsgi_sock->family = AF_INET;
+			uwsgi_sock->bound = 1;
+
+			uwsgi_sock->auto_port = 1;
+
+			socket_type_len = sizeof(struct sockaddr_in);
+
+			if (getsockname(uwsgi_sock->fd, (struct sockaddr *)&sin, &socket_type_len)) {
+				uwsgi_error("getsockname()");
+				exit(1);
+			}
+
+
+			char *auto_port = uwsgi_num2str(ntohs(sin.sin_port));
+			uwsgi_sock->name = uwsgi_concat3n(name, tcp_port-name, ":", 1, auto_port, strlen(auto_port));
+		}	
+	}
 	
 	return uwsgi_sock;
 }
@@ -597,6 +769,11 @@ void uwsgi_add_socket_from_fd(struct uwsgi_socket *uwsgi_sock, int fd) {
 	socklen_t socket_type_len;
 	union uwsgi_sockaddr_ptr gsa, isa;
 	union uwsgi_sockaddr usa;
+	int abstract = 0;
+
+#ifdef UWSGI_DEBUG
+	uwsgi_log("creating socket from fd %d\n", fd);
+#endif
 
 	socket_type_len = sizeof(struct sockaddr_un);
 	gsa.sa = &usa.sa;
@@ -606,7 +783,17 @@ void uwsgi_add_socket_from_fd(struct uwsgi_socket *uwsgi_sock, int fd) {
 			return;
 		}
 		if (gsa.sa->sa_family == AF_UNIX) {
-			if (!strcmp(usa.sa_un.sun_path, uwsgi_sock->name)) {
+			if (usa.sa_un.sun_path[0] == 0) abstract = 1;
+			// is it a zerg ?
+			if (uwsgi_sock->name == NULL) {
+				uwsgi_sock->fd = fd;
+				uwsgi_sock->family = AF_UNIX;
+				uwsgi_sock->bound = 1;
+				uwsgi_sock->name = uwsgi_concat2(usa.sa_un.sun_path+abstract, "");
+				uwsgi_log("uwsgi zerg socket %d attached to UNIX address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), usa.sa_un.sun_path+abstract, uwsgi_sock->fd);
+				return;
+			}
+			if (!strcmp(usa.sa_un.sun_path+abstract, uwsgi_sock->name+abstract)) {
 				uwsgi_sock->fd = fd;
 				uwsgi_sock->family = AF_UNIX;
 				uwsgi_sock->bound = 1;
@@ -631,6 +818,17 @@ void uwsgi_add_socket_from_fd(struct uwsgi_socket *uwsgi_sock, int fd) {
 					else {
 						computed_addr = uwsgi_concat3(ipv4a, ":", computed_port);
 					}
+
+					// is it a zerg ?
+                        		if (uwsgi_sock->name == NULL) {
+						uwsgi_sock->fd = fd;
+						uwsgi_sock->family = AF_INET;
+						uwsgi_sock->bound = 1;
+						uwsgi_sock->name = uwsgi_concat2(computed_addr, "");
+						uwsgi_log("uwsgi zerg socket %d attached to INET address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), computed_addr, uwsgi_sock->fd);
+						free(computed_addr);
+						return;
+					}
 					char *asterisk = strchr(uwsgi_sock->name, '*');
 					int match = 1;
 					if (asterisk) {
@@ -691,3 +889,46 @@ struct uwsgi_socket *uwsgi_del_socket(struct uwsgi_socket *uwsgi_sock) {
 	return NULL;
 }
 
+
+int uwsgi_get_shared_socket_fd_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->fd;
+	}
+	
+	return -1;
+}
+
+void uwsgi_add_sockets_to_queue(int queue) {
+
+	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+                while(uwsgi_sock) {
+                        event_queue_add_fd_read(queue, uwsgi_sock->fd);
+                        uwsgi_sock = uwsgi_sock->next;
+                }
+
+}
+
+void uwsgi_del_sockets_from_queue(int queue) {
+
+        struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+                while(uwsgi_sock) {
+                        event_queue_del_fd(queue, uwsgi_sock->fd, event_queue_read());
+                        uwsgi_sock = uwsgi_sock->next;
+                }
+
+}
+

spooler.c

@@ -3,7 +3,26 @@
 
 extern struct uwsgi_server uwsgi;
 
+static void spooler_readdir(char *);
+#ifdef __linux__
+static void spooler_scandir(char *);
+#endif
+void spooler_manage_task(char *, char *);
+
 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();
 	if (pid < 0) {
@@ -11,21 +30,35 @@ pid_t spooler_start() {
 		exit(1);
 	}
 	else if (pid == 0) {
-		struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
-		while(uwsgi_sock) {
-			close(uwsgi_sock->fd);
-			uwsgi_sock = uwsgi_sock->next;
+		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]);
+				}
+			}
 		}
+		uwsgi.signal_socket = uwsgi.shared->spooler_signal_pipe[1];
 		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);
 	}
 
 	return pid;
 }
 
-void destroy_spool(char *file) {
+void destroy_spool(char *dir, char *file) {
+
+	if (chdir(dir)) {
+		uwsgi_error("chdir()");
+                uwsgi_log("something horrible happened to the spooler. Better to kill it.\n");
+		exit(1);
+	}
 
 	if (unlink(file)) {
         	uwsgi_error("unlink()");
@@ -36,7 +69,7 @@ void destroy_spool(char *file) {
 }
 
 
-int spool_request(char *filename, int rn, int core_id, char *buffer, int size) {
+int spool_request(char *filename, int rn, int core_id, char *buffer, int size, char *priority, time_t at, char *body, size_t body_len) {
 
 	struct timeval tv;
 	int fd;
@@ -46,9 +79,24 @@ int spool_request(char *filename, int rn, int core_id, char *buffer, int size) {
 
 	gettimeofday(&tv, NULL);
 
-	if (snprintf(filename, 1024, "%s/uwsgi_spoolfile_on_%s_%d_%d_%d_%llu_%llu", uwsgi.spool_dir, uwsgi.hostname, (int) getpid(), rn, core_id, (unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec) <= 0) {
-		uwsgi_unlock(uwsgi.spooler_lock);
-		return 0;
+	if (priority) {
+		if (snprintf(filename, 1024, "%s/%s", uwsgi.spool_dir, priority) <= 0) {
+			uwsgi_unlock(uwsgi.spooler_lock);
+			return 0;
+		}
+		// no need to check for errors...
+		(void) mkdir(filename, 0777);
+
+		if (snprintf(filename, 1024, "%s/%s/uwsgi_spoolfile_on_%s_%d_%d_%d_%llu_%llu", uwsgi.spool_dir, priority, uwsgi.hostname, (int) getpid(), rn, core_id, (unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec) <= 0) {
+			uwsgi_unlock(uwsgi.spooler_lock);
+			return 0;
+		}
+	}
+	else {
+		if (snprintf(filename, 1024, "%s/uwsgi_spoolfile_on_%s_%d_%d_%d_%llu_%llu", uwsgi.spool_dir, uwsgi.hostname, (int) getpid(), rn, core_id, (unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec) <= 0) {
+			uwsgi_unlock(uwsgi.spooler_lock);
+			return 0;
+		}
 	}
 
 	fd = open(filename, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR);
@@ -85,9 +133,30 @@ int spool_request(char *filename, int rn, int core_id, char *buffer, int size) {
 		goto clear;
 	}
 
+	if (body && body_len > 0) {
+		if ((size_t)write(fd, body, body_len) != body_len) {
+			goto clear;	
+		}
+	}
+
+	if (at > 0) {
+		struct timeval tv[2];
+		tv[0].tv_sec = at;
+		tv[0].tv_usec = 0;
+		tv[1].tv_sec = at;
+		tv[1].tv_usec = 0;
+#ifdef __sun__
+		if (futimesat(fd, NULL, tv)) {
+#else
+		if (futimes(fd, tv)) {
+#endif
+			uwsgi_error("futimes()");
+		}
+	}
+
 	close(fd);
 
-	uwsgi_log("written %d bytes to spool file %s\n", size + 4, filename);
+	uwsgi_log("written %d bytes to spool file %s\n", size + body_len + 4, filename);
 	
 	uwsgi_unlock(uwsgi.spooler_lock);
 
@@ -105,31 +174,20 @@ int spool_request(char *filename, int rn, int core_id, char *buffer, int size) {
 
 
 void spooler() {
-	DIR *sdir;
-	struct dirent *dp;
-	int i, ret;
-
-
-	int spool_fd;
 
 	// prevent process blindly reading stdin to make mess
 	int nullfd;
 
-	struct uwsgi_header uh;
-
-	char spool_buf[0xffff];
-
-	if (chdir(uwsgi.spool_dir)) {
-		uwsgi_error("chdir()");
-		exit(1);
-	}
-
 	// asked by Marco Beri
 #ifdef __HAIKU__
+#ifdef UWSGI_DEBUG
 	uwsgi_log("lowering spooler priority to %d\n", B_LOW_PRIORITY);
+#endif
 	set_thread_priority(find_thread(NULL), B_LOW_PRIORITY);
 #else
+#ifdef UWSGI_DEBUG
 	uwsgi_log("lowering spooler priority to %d\n", PRIO_MAX);
+#endif
 	setpriority(PRIO_PROCESS, getpid(), PRIO_MAX);
 #endif
 
@@ -144,85 +202,205 @@ void spooler() {
 		close(nullfd);
 	}
 
+	int spooler_event_queue = event_queue_init();
+	int interesting_fd = -1;
+
+	if (uwsgi.master_process) {
+		event_queue_add_fd_read(spooler_event_queue, uwsgi.shared->spooler_signal_pipe[1]);
+	}
+
 	for (;;) {
 
-		sleep(uwsgi.shared->spooler_frequency);
 
-		sdir = opendir(uwsgi.spool_dir);
-		if (sdir) {
-			while ((dp = readdir(sdir)) != NULL) {
-				if (!strncmp("uwsgi_spoolfile_on_", dp->d_name, 19)) {
-					struct stat sf_lstat;
-					if (lstat(dp->d_name, &sf_lstat)) {
-						continue;
-					}
-					if (!S_ISREG(sf_lstat.st_mode)) {
-						continue;
-					}
-					if (!access(dp->d_name, R_OK | W_OK)) {
-						uwsgi_log("managing spool request %s ...\n", dp->d_name);
+		if (chdir(uwsgi.spool_dir)) {
+			uwsgi_error("chdir()");
+			exit(1);
+		}
 
-						spool_fd = open(dp->d_name, O_RDONLY);
-						if (spool_fd < 0) {
-							uwsgi_error_open(dp->d_name);
-							continue;
-						}
-
-#ifdef __sun__
-						if (lockf(spool_fd, F_LOCK, 0)) {
-							uwsgi_error("lockf()");
-#else
-						if (flock(spool_fd, LOCK_EX)) {
-							uwsgi_error("flock()");
+		if (uwsgi.spooler_ordered) {
+#ifdef __linux__
+			spooler_scandir(uwsgi.spool_dir);
 #endif
-							close(spool_fd);
-							continue;
-						}
-
-						if (read(spool_fd, &uh, 4) != 4) {
-							uwsgi_error("read()");
-							close(spool_fd);
-							continue;
-						}
-
-#ifdef __BIG_ENDIAN__
-						uh.pktsize = uwsgi_swap16(uh.pktsize);
-#endif
-
-
-						if (read(spool_fd, spool_buf, uh.pktsize) != uh.pktsize) {
-							uwsgi_error("read()");
-							destroy_spool(dp->d_name);	
-							close(spool_fd);
-							continue;
-						}			
-					
-
-						close(spool_fd);
-
-						for(i=0;i<0xff;i++) {
-							if (uwsgi.p[i]->spooler) {
-								ret = uwsgi.p[i]->spooler(spool_buf, uh.pktsize);
-								if (ret == 0) continue;
-								if (ret == -2) {
-
-									uwsgi_log("done with task/spool %s\n", dp->d_name);
-									destroy_spool(dp->d_name);	
-								}
-								// re-spool it
-								break;	
-							}
-						}
-
-					}
-				}
-			}
-			closedir(sdir);
 		}
 		else {
-			uwsgi_error("opendir()");
+			spooler_readdir(uwsgi.spool_dir);
 		}
 
+		if (event_queue_wait(spooler_event_queue, uwsgi.shared->spooler_frequency, &interesting_fd) > 0) {
+			if (uwsgi.master_process) {
+				if (interesting_fd == uwsgi.shared->spooler_signal_pipe[1]) {
+					uint8_t uwsgi_signal;
+					if (read(interesting_fd, &uwsgi_signal, 1) <= 0) {
+                                        	if (uwsgi.no_orphans) {
+                                                	uwsgi_log_verbose("uWSGI spooler screams: UAAAAAAH my master died, i will follow him...\n");
+                                               		end_me(0); 
+                                        	}
+                                	}
+                                	else {
+#ifdef UWSGI_DEBUG
+                                        	uwsgi_log_verbose("master sent signal %d to the spooler\n", uwsgi_signal);
+#endif
+                                        	if (uwsgi_signal_handler(uwsgi_signal)) {
+                                                	uwsgi_log_verbose("error managing signal %d on the spooler\n", uwsgi_signal);
+                                        	}
+                                	}
+				}
+			}
+		}
+
+	}
+}
+
+#ifdef __linux__
+static void spooler_scandir(char *dir) {
+
+	struct dirent **tasklist;
+	int n;
+
+	n = scandir(dir, &tasklist, 0, versionsort);
+	if (n < 0) {
+		uwsgi_error("scandir()");
+		return;
+	}
+	
+	while(n--) {
+		spooler_manage_task(dir, tasklist[n]->d_name);
+		free(tasklist[n]);	
+	}
+
+	free(tasklist);
+}
+#endif
+
+
+static void spooler_readdir(char *dir) {
+
+	DIR *sdir;
+	struct dirent *dp;
+
+	sdir = opendir(dir);
+	if (sdir) {
+		while ((dp = readdir(sdir)) != NULL) {
+			spooler_manage_task(dir, dp->d_name);
+		}
+		closedir(sdir);
+	}
+	else {
+		uwsgi_error("opendir()");
+	}
+}
+
+void spooler_manage_task(char *dir, char *task) {
+
+	int i, ret;
+
+	char spool_buf[0xffff];
+	struct uwsgi_header uh;
+	char *body = NULL;
+	size_t body_len = 0;
+
+	int spool_fd;
+
+	if (!strncmp("uwsgi_spoolfile_on_", task, 19) || (uwsgi.spooler_ordered && is_a_number(task))) {
+		struct stat sf_lstat;
+		if (lstat(task, &sf_lstat)) {
+			return;
+		}
+
+		// a spool request for the future
+		if (sf_lstat.st_mtime > time(NULL)) {
+			return;
+		}
+
+#ifdef __linux__
+		if (S_ISDIR(sf_lstat.st_mode) && uwsgi.spooler_ordered) {
+			if (chdir(task)) {
+				uwsgi_error("chdir()");
+				return;
+			}
+			char *prio_path = realpath(".", NULL);
+			spooler_scandir(prio_path);
+			free(prio_path);
+			if (chdir(dir)) {
+				uwsgi_error("chdir()");
+			}
+			return;
+		}
+#endif
+		if (!S_ISREG(sf_lstat.st_mode)) {
+			return;
+		}
+		if (!access(task, R_OK | W_OK)) {
+			uwsgi_log("managing spool request %s ...\n", task);
+
+			spool_fd = open(task, O_RDONLY);
+			if (spool_fd < 0) {
+				uwsgi_error_open(task);
+				return;
+			}
+
+#ifdef __sun__
+			if (lockf(spool_fd, F_LOCK, 0)) {
+				uwsgi_error("lockf()");
+#else
+			if (flock(spool_fd, LOCK_EX)) {
+				uwsgi_error("flock()");
+#endif
+				close(spool_fd);
+				return;
+			}
+
+			if (read(spool_fd, &uh, 4) != 4) {
+				uwsgi_error("read()");
+				close(spool_fd);
+				return;
+			}
+
+#ifdef __BIG_ENDIAN__
+			uh.pktsize = uwsgi_swap16(uh.pktsize);
+#endif
+
+			if (read(spool_fd, spool_buf, uh.pktsize) != uh.pktsize) {
+				uwsgi_error("read()");
+				destroy_spool(dir, task);	
+				close(spool_fd);
+				return;
+			}			
+					
+			// body available ?
+			if (sf_lstat.st_size > (uh.pktsize+4)) {
+				body_len = sf_lstat.st_size - (uh.pktsize+4);
+				body = uwsgi_malloc(body_len);
+				if ((size_t)read(spool_fd, body, body_len) != body_len) {
+					uwsgi_error("read()");
+					destroy_spool(dir, task);
+					close(spool_fd);
+					free(body);
+					return;
+				}
+			}
+
+			close(spool_fd);
+
+			for(i=0;i<0xff;i++) {
+				if (uwsgi.p[i]->spooler) {
+					time_t now = time(NULL);
+					ret = uwsgi.p[i]->spooler(task, spool_buf, uh.pktsize, body, body_len);
+					if (body) {
+						free(body);
+					}
+					if (ret == 0) continue;
+					if (ret == -2) {
+
+						uwsgi_log("done with task/spool %s after %d seconds\n", task, time(NULL)-now);
+						destroy_spool(dir, task);	
+					}
+					// re-spool it
+					break;	
+				}
+			}
+
+		}
 	}
 }
 
@@ -239,7 +417,7 @@ int uwsgi_request_spooler(struct wsgi_request *wsgi_req) {
 	}
 
 	uwsgi_log("managing spool request...\n");
-	i = spool_request(spool_filename, uwsgi.workers[0].requests + 1, wsgi_req->async_id, wsgi_req->buffer, wsgi_req->uh.pktsize);
+	i = spool_request(spool_filename, uwsgi.workers[0].requests + 1, wsgi_req->async_id, wsgi_req->buffer, wsgi_req->uh.pktsize, NULL, 0, NULL, 0);
 	wsgi_req->uh.modifier1 = 255;
 	wsgi_req->uh.pktsize = 0;
 	if (i > 0) {

sqlite3.c

@@ -5,18 +5,19 @@
 
 extern struct uwsgi_server uwsgi;
 
-static int uwsgi_sqlite3_config_callback(void *foo, int field_count, char **fields, char **col) {
-
+static int uwsgi_sqlite3_config_callback(void *magic_table, int field_count, char **fields, char **col) {
 	// make a copy of the string
 	if (field_count >= 2) {
-		add_exported_option( uwsgi_strncopy(fields[0], strlen(fields[0])), uwsgi_strncopy(fields[1], strlen(fields[1])), 0);
+		int value_len = strlen(fields[1]) + 1;
+		char *value = magic_sub(fields[1], value_len, &value_len, (char **) magic_table);
+		add_exported_option( uwsgi_strncopy(fields[0], strlen(fields[0])), value, 0);
 	}
 
 	return 0;
 }
 
 
-void uwsgi_sqlite3_config(char *file) {
+void uwsgi_sqlite3_config(char *file, char *magic_table[]) {
 
 	sqlite3 *db;
 	char *err = NULL;		
@@ -43,7 +44,7 @@ void uwsgi_sqlite3_config(char *file) {
 		exit(1);
 	}
 
-	if (sqlite3_exec(db, query, uwsgi_sqlite3_config_callback, 0, &err)) {
+	if (sqlite3_exec(db, query, uwsgi_sqlite3_config_callback, (void *) magic_table, &err)) {
 		uwsgi_log("sqlite3 error: %s\n", err);
 		sqlite3_close(db);
 		exit(1);

taskqueue.py

@@ -0,0 +1,36 @@
+import Queue
+from threading import Thread
+import uwsgi
+
+CONSUMERS = 4
+
+def consumer(q):
+    while True:
+        item = q.get()
+        print(item)
+        #... DO A HEAVY TASK HERE ...
+        q.task_done()
+
+def spawn_consumers():
+    global q
+    q = Queue.Queue()
+    for i in range(CONSUMERS):
+        t = Thread(target=consumer,args=(q,))
+        t.daemon = True
+        t.start()
+        print("consumer %d on worker %d started" % (i, uwsgi.worker_id()))
+    
+
+uwsgi.post_fork_hook = spawn_consumers
+
+
+def application(env, start_response):
+    global q
+
+    # we pass a copy of the env dictionary as it gets cleared after yield/return
+    q.put(env.copy())
+
+    start_response('200 OK', [('Content-Type', 'text/html')])
+
+    yield "Task enqueued"
+    

tests/cpubound_green.py

@@ -6,7 +6,7 @@ def application(env, start_response):
 	start_response( '200 OK', [ ('Content-Type','text/html') ])
 	start_time = time.time()
 	for i in range(1,100000):
-		uwsgi.green_schedule()
+		uwsgi.suspend()
 		# print every 100
 		if i % 100 == 0:
 			yield "<h1>%d</h1>\n" % i

uploadtest.py

@@ -5,8 +5,9 @@ def application(env, start_response):
     	start_response('200 Ok', [('Content-type', 'text/plain')])
 	#for x in env['wsgi.input']:
 	#	yield x
-	body = env['wsgi.input'].readline()
-	print body
+	body = env['wsgi.input'].read(int(env['CONTENT_LENGTH']))
+	body += env['wsgi.input'].readline()
+	#print body
 	body += env['wsgi.input'].read(100)
 	body += env['wsgi.input'].read(100)
 	body += env['wsgi.input'].read()
@@ -17,7 +18,7 @@ def application(env, start_response):
 <form method="POST" enctype="multipart/form-data">
 	<textarea name="pluto">
 	</textarea>
-    <input type="test" name="pippo" />
+    <input type="file" name="pippo" />
     <input type="submit" value="invia" />
 </form>
         """

utils.c

@@ -259,6 +259,50 @@ void log_zeromq(char *node) {
 }
 #endif
 
+void log_socket(char *socket_name) {
+
+	int family = AF_UNIX;
+
+	uwsgi.log_socket_addr = uwsgi_malloc(sizeof(union uwsgi_sockaddr));
+
+	char *colon = strchr(socket_name, ':');
+	if (colon) {
+		family = AF_INET;
+		uwsgi.log_socket_size = socket_to_in_addr(socket_name, colon, &uwsgi.log_socket_addr->sa_in);
+	}
+	else {
+		uwsgi.log_socket_size = socket_to_un_addr(socket_name, &uwsgi.log_socket_addr->sa_un);	
+	}
+
+	uwsgi.log_socket_fd = socket(family, SOCK_DGRAM, 0);
+	if (uwsgi.log_socket_fd < 0) {
+		uwsgi_error("socket()");
+		uwsgi_nuclear_blast();
+	}
+
+	// create log connection with the master
+
+	if (socketpair(AF_UNIX, SOCK_DGRAM, 0, uwsgi.shared->worker_log_pipe)) {
+                uwsgi_error("socketpair()\n");
+                exit(1);
+        }
+
+        uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[0]);
+        uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[1]);
+
+	if (uwsgi.shared->worker_log_pipe[1] != 1) {
+                if (dup2(uwsgi.shared->worker_log_pipe[1], 1) < 0) {
+                        uwsgi_error("dup2()");
+                        exit(1);
+                }
+        }
+
+        if (dup2(1, 2) < 0) {
+                uwsgi_error("dup2()");
+                exit(1);
+        }
+
+}
 
 void log_syslog(char *syslog_opts) {
 
@@ -371,69 +415,89 @@ void internal_server_error(struct wsgi_request *wsgi_req, char *message) {
 	uwsgi.wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, message, strlen(message));
 }
 
-void uwsgi_as_root() {
-
 #ifdef __linux__
+void uwsgi_set_cgroup() {
+
 	char *cgroup_taskfile;
-	int i;
 	FILE *cgroup;
 	char *cgroup_opt;
+	struct uwsgi_string_list *usl, *uslo;
+
+	if (!uwsgi.cgroup) return;
+
+	usl = uwsgi.cgroup;
+
+	while(usl) {
+		if (mkdir(usl->value, 0700)) {
+                	uwsgi_log("using Linux cgroup %s\n", usl->value);
+			if (errno != EEXIST) {
+				uwsgi_error("mkdir()");
+			}
+                }
+                else {
+                	uwsgi_log("created Linux cgroup %s\n", usl->value);
+                }
+
+                cgroup_taskfile = uwsgi_concat2(usl->value, "/tasks");
+                cgroup = fopen(cgroup_taskfile, "w");
+                if (!cgroup) {
+                	uwsgi_error_open(cgroup_taskfile);
+                        exit(1);
+                }
+                if (fprintf(cgroup, "%d", (int) getpid()) <= 0) {
+                	uwsgi_log("could not set cgroup\n");
+                        exit(1);
+                }
+		uwsgi_log("assigned process %d to cgroup %s\n", (int) getpid(), cgroup_taskfile);
+                fclose(cgroup);
+                free(cgroup_taskfile);
+
+
+		uslo = uwsgi.cgroup_opt;
+		while(uslo) {
+                                cgroup_opt = strchr(uslo->value, '=');
+                                if (!cgroup_opt) {
+                                        cgroup_opt = strchr(uslo->value, ':');
+                                        if (!cgroup_opt) {
+                                                uwsgi_log("invalid cgroup-opt syntax\n");
+                                                exit(1);
+                                        }
+                                }
+
+                                cgroup_opt[0] = 0;
+                                cgroup_opt++;
+
+                                cgroup_taskfile = uwsgi_concat3(usl->value, "/", uslo->value);
+                                cgroup = fopen(cgroup_taskfile, "w");
+                                if (cgroup) {
+                                	if (fprintf(cgroup, "%s\n", cgroup_opt) < 0) {
+                                        	uwsgi_log("could not set cgroup option %s to %s\n", uslo->value, cgroup_opt);
+                                        	exit(1);
+					}
+                                	fclose(cgroup);
+					uwsgi_log("set %s to %s\n", cgroup_opt, cgroup_taskfile);
+                                }
+                                free(cgroup_taskfile);
+
+				cgroup_opt[-1] = '=';
+
+				uslo = uslo->next;
+                        }
+
+		usl = usl->next;
+	}
+
+}
 #endif
 
+void uwsgi_as_root() {
+
+
 	if (!getuid()) {
 		if (!uwsgi.master_as_root && !uwsgi.uidname) {
 			uwsgi_log("uWSGI running as root, you can use --uid/--gid/--chroot options\n");
 		}
 
-#ifdef __linux__
-		if (uwsgi.cgroup) {
-			if (mkdir(uwsgi.cgroup, S_IRWXU | S_IROTH | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
-				uwsgi_log("using Linux cgroup %s\n", uwsgi.cgroup);
-			}
-			else {
-				uwsgi_log("created Linux cgroup %s\n", uwsgi.cgroup);
-			}
-			cgroup_taskfile = uwsgi_concat2(uwsgi.cgroup, "/tasks");
-			cgroup = fopen(cgroup_taskfile, "w");
-			if (!cgroup) {
-				uwsgi_error_open(cgroup_taskfile);
-				exit(1);
-			}
-			if (fprintf(cgroup, "%d\n", (int) getpid()) < 0) {
-				uwsgi_log("could not set cgroup\n");
-				exit(1);
-			}
-			fclose(cgroup);
-			free(cgroup_taskfile);
-
-			for (i = 0; i < uwsgi.cgroup_opt_cnt; i++) {
-				cgroup_opt = strchr(uwsgi.cgroup_opt[i], '=');
-				if (!cgroup_opt) {
-					cgroup_opt = strchr(uwsgi.cgroup_opt[i], ':');
-					if (!cgroup_opt) {
-						uwsgi_log("invalid cgroup-opt syntax\n");
-						exit(1);
-					}
-				}
-
-				cgroup_opt[0] = 0;
-				cgroup_opt++;
-
-				cgroup_taskfile = uwsgi_concat3(uwsgi.cgroup, "/", uwsgi.cgroup_opt[i]);
-				cgroup = fopen(cgroup_taskfile, "w");
-				if (!cgroup) {
-					uwsgi_error_open(cgroup_taskfile);
-					exit(1);
-				}
-				if (fprintf(cgroup, "%s\n", cgroup_opt) < 0) {
-					uwsgi_log("could not set cgroup option %s to %s\n", uwsgi.cgroup_opt[i], cgroup_opt);
-					exit(1);
-				}
-				fclose(cgroup);
-				free(cgroup_taskfile);
-			}
-		}
-#endif
 		if (uwsgi.chroot && !uwsgi.reloads) {
 			if (!uwsgi.master_as_root)
 				uwsgi_log("chroot() to %s\n", uwsgi.chroot);
@@ -666,7 +730,7 @@ int wsgi_req_recv(struct wsgi_request *wsgi_req) {
 	gettimeofday(&wsgi_req->start_of_request, NULL);
 
 	if (!wsgi_req->socket->edge_trigger) {
-		if (!uwsgi_parse_response(&wsgi_req->poll, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], (struct uwsgi_header *) wsgi_req, wsgi_req->buffer, wsgi_req->socket->proto)) {
+		if (!uwsgi_parse_packet(wsgi_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT])) {
 			return -1;
 		}
 	}
@@ -697,15 +761,17 @@ int wsgi_req_simple_accept(struct wsgi_request *wsgi_req, int fd) {
 	return 0;
 }
 
-int wsgi_req_accept(struct wsgi_request *wsgi_req) {
+int wsgi_req_accept(int queue, struct wsgi_request *wsgi_req) {
 
 	int ret;
 	int interesting_fd;
 	char uwsgi_signal;
 	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
 
-	ret = event_queue_wait(uwsgi.main_queue, uwsgi.edge_triggered - 1, &interesting_fd);
+	thunder_lock;
+	ret = event_queue_wait(queue, uwsgi.edge_triggered - 1, &interesting_fd);
 	if (ret < 0) {
+		thunder_unlock;
 		return -1;
 	}
 
@@ -714,7 +780,10 @@ int wsgi_req_accept(struct wsgi_request *wsgi_req) {
 	if (uwsgi.threads > 1) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &ret);
 #endif
 
-	if (uwsgi.signal_socket > -1 && interesting_fd == uwsgi.signal_socket) {
+	if (uwsgi.signal_socket > -1 && (interesting_fd == uwsgi.signal_socket || interesting_fd == uwsgi.my_signal_socket)) {
+
+		thunder_unlock;
+
 		if (read(interesting_fd, &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);
@@ -725,7 +794,9 @@ int wsgi_req_accept(struct wsgi_request *wsgi_req) {
 			}
 		}
 		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);
 			}
@@ -742,6 +813,7 @@ int wsgi_req_accept(struct wsgi_request *wsgi_req) {
 		if (interesting_fd == uwsgi_sock->fd || (uwsgi.edge_triggered && uwsgi_sock->edge_trigger)) {
 			wsgi_req->socket = uwsgi_sock;
 			wsgi_req->poll.fd = wsgi_req->socket->proto_accept(wsgi_req, interesting_fd);
+			thunder_unlock;
 			if (wsgi_req->poll.fd < 0) {
 #ifdef UWSGI_THREADING
         			if (uwsgi.threads > 1) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &ret);
@@ -776,6 +848,7 @@ int wsgi_req_accept(struct wsgi_request *wsgi_req) {
 		uwsgi_sock = uwsgi_sock->next;
 	}
 
+	thunder_unlock;
 #ifdef UWSGI_THREADING
         if (uwsgi.threads > 1) pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &ret);
 #endif
@@ -855,6 +928,7 @@ void uwsgi_log(const char *fmt, ...) {
 	va_list ap;
 	char logpkt[4096];
 	int rlen = 0;
+	int ret;
 
 	struct timeval tv;
 	char sftime[64];
@@ -879,9 +953,21 @@ void uwsgi_log(const char *fmt, ...) {
 	}
 
 	va_start(ap, fmt);
-	rlen += vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);
+	ret = vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);
 	va_end(ap);
 
+	if (ret >= 4096) {
+		char *tmp_buf = uwsgi_malloc(rlen + ret + 1);
+		memcpy(tmp_buf, logpkt, rlen);
+		va_start(ap, fmt);
+		ret = vsnprintf(tmp_buf + rlen,  ret+1, fmt, ap);
+		va_end(ap);
+		rlen = write(2, tmp_buf, rlen+ret);
+		free(tmp_buf);
+		return;
+	}
+
+	rlen+=ret;
 	// do not check for errors
 	rlen = write(2, logpkt, rlen);
 }
@@ -893,13 +979,26 @@ void uwsgi_log_verbose(const char *fmt, ...) {
 	int rlen = 0;
 
 	struct timeval tv;
+	char sftime[64];
+        time_t now;
 
-	gettimeofday(&tv, NULL);
+		if (uwsgi.log_strftime) {
+                        now = time(NULL);
+                        rlen = strftime(sftime, 64, uwsgi.log_strftime, localtime(&now));
+                        memcpy(logpkt, sftime, rlen);
+                        memcpy(logpkt + rlen, " - ", 3);
+                        rlen += 3;
+                }
+                else {
+                        gettimeofday(&tv, NULL);
 
-	memcpy(logpkt, ctime((const time_t *) &tv.tv_sec), 24);
-	memcpy(logpkt + 24, " - ", 3);
+                        memcpy(logpkt, ctime((const time_t *) &tv.tv_sec), 24);
+                        memcpy(logpkt + 24, " - ", 3);
+
+                        rlen = 24 + 3;
+                }
+	
 
-	rlen = 24 + 3;
 
 	va_start(ap, fmt);
 	rlen += vsnprintf(logpkt + rlen, 4096 - rlen, fmt, ap);
@@ -1170,8 +1269,10 @@ int uwsgi_get_app_id(char *script_name, int script_name_len, int modifier1) {
 	struct stat st;
 
 	for (i = 0; i < uwsgi.apps_cnt; i++) {
-		//uwsgi_log("searching for %.*s in %.*s %p\n", script_name_len, script_name, uwsgi.apps[i].mountpoint_len, uwsgi.apps[i].mountpoint, uwsgi.apps[i].callable);
-		if (!uwsgi.apps[i].mountpoint_len) {
+#ifdef UWSGI_DEBUG
+		uwsgi_log("searching for %.*s in %.*s %p\n", script_name_len, script_name, uwsgi.apps[i].mountpoint_len, uwsgi.apps[i].mountpoint, uwsgi.apps[i].callable);
+#endif
+		if (!uwsgi.apps[i].callable) {
 			continue;
 		}
 		if (!uwsgi_strncmp(uwsgi.apps[i].mountpoint, uwsgi.apps[i].mountpoint_len, script_name, script_name_len)) {
@@ -1180,7 +1281,13 @@ int uwsgi_get_app_id(char *script_name, int script_name_len, int modifier1) {
 					if (st.st_mtime != uwsgi.apps[i].touch_reload_mtime) {
 						// serve the new request and reload
 						uwsgi.workers[uwsgi.mywid].manage_next_request = 0;
-						return -1;
+						if (uwsgi.threads > 1) {
+							uwsgi.workers[uwsgi.mywid].destroy = 1;
+						}
+
+#ifdef UWSGI_DEBUG
+						uwsgi_log("mtime %d %d\n", st.st_mtime, uwsgi.apps[i].touch_reload_mtime);
+#endif
 					}
 				}
 			}
@@ -1226,7 +1333,7 @@ int uwsgi_read_whole_body_in_mem(struct wsgi_request *wsgi_req, char *buf) {
 		}
 
 		if (!ret) {
-			uwsgi_log("buffering POST data timedout !!!\n");
+			uwsgi_log("buffering POST data timed-out !!!\n");
 			return 0;
 		}
 
@@ -1503,6 +1610,11 @@ char *uwsgi_resolve_ip(char *domain) {
 	return inet_ntoa(*(struct in_addr *) he->h_addr_list[0]);
 }
 
+int uwsgi_file_exists(char *filename) {
+	// TODO check for http url or stdin
+	return !access(filename, R_OK);
+}
+
 char *uwsgi_open_and_read(char *url, int *size, int add_zero, char *magic_table[]) {
 
 	int fd;
@@ -1668,6 +1780,42 @@ char *uwsgi_open_and_read(char *url, int *size, int add_zero, char *magic_table[
 			buffer[*size - 1] = 0;
 		}
 	}
+#ifdef UWSGI_EMBED_CONFIG
+	else if (url[0] == 0) {
+		*size = &UWSGI_EMBED_CONFIG_END-&UWSGI_EMBED_CONFIG;
+		if (add_zero) {
+			*size+=1;
+		}
+		buffer = uwsgi_malloc(*size);
+		memset(buffer, 0, *size);
+		memcpy(buffer, &UWSGI_EMBED_CONFIG, &UWSGI_EMBED_CONFIG_END-&UWSGI_EMBED_CONFIG);
+	}
+#endif
+	else if (!strncmp("sym://", url, 6)) {
+		char *symbol = uwsgi_concat3("_binary_", url+6, "_start") ;
+		void *sym_start_ptr = dlsym(RTLD_DEFAULT, symbol);
+		if (!sym_start_ptr) {
+			uwsgi_log("unable to find symbol %s\n", symbol);	
+			exit(1);
+		}
+		free(symbol);
+		symbol = uwsgi_concat3("_binary_", url+6, "_end");
+		void *sym_end_ptr = dlsym(RTLD_DEFAULT, symbol);
+                if (!sym_end_ptr) {
+                        uwsgi_log("unable to find symbol %s\n", symbol);
+                        exit(1);
+                }
+                free(symbol);
+
+		*size = sym_end_ptr - sym_start_ptr;
+		if (add_zero) {
+                        *size+=1;
+                }
+                buffer = uwsgi_malloc(*size);
+                memset(buffer, 0, *size);
+                memcpy(buffer, sym_start_ptr, sym_end_ptr - sym_start_ptr);
+
+	}
 	// fallback to file
 	else {
 		fd = open(url, O_RDONLY);
@@ -1804,11 +1952,7 @@ void spawn_daemon(struct uwsgi_daemon *ud) {
 	char *argv[64];
 	char *a;
 	int cnt = 1;
-
-	if (socketpair(AF_UNIX, SOCK_STREAM, 0, ud->pipe)) {
-		uwsgi_error("socketpair()");
-		return;
-	}
+	int devnull = -1;
 
 	pid_t pid = fork();
 	if (pid < 0) {
@@ -1817,7 +1961,6 @@ void spawn_daemon(struct uwsgi_daemon *ud) {
 	}
 
 	if (pid > 0) {
-		close(ud->pipe[1]);
 		ud->pid = pid;
 		ud->status = 1;
 		if (ud->respawns == 0) {
@@ -1829,23 +1972,27 @@ void spawn_daemon(struct uwsgi_daemon *ud) {
 
 	}
 	else {
-
 		// close uwsgi sockets
-		struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
-		while(uwsgi_sock) {
-			close(uwsgi_sock->fd);
-			uwsgi_sock = uwsgi_sock->next;
-		}
-		close(ud->pipe[0]);
+		uwsgi_close_all_sockets();
 
-		// stdin will become the pipe
-		if (ud->pipe[1] != 0) {
-			if (dup2(ud->pipe[1], 0)) {
+		// /dev/null will became stdin
+		devnull = open("/dev/null", O_RDONLY);	
+		if (devnull < 0) {
+			uwsgi_error("/dev/null open()");
+			exit(1);
+		}
+		if (devnull != 0) {
+			if (dup2(devnull, 0)) {
 				uwsgi_error("dup2()");
 				exit(1);
 			}
 		}
 
+		if (setsid() < 0) {
+			uwsgi_error("setsid()");
+			exit(1);
+		}
+
 #ifdef __linux__
 		if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0)) {
 			uwsgi_error("prctl()");
@@ -2169,6 +2316,7 @@ struct uwsgi_string_list *uwsgi_string_new_list(struct uwsgi_string_list **list,
         }
 
         uwsgi_string->value = value;
+        uwsgi_string->len = strlen(value);
 	uwsgi_string->next = NULL;
 
         return uwsgi_string;
@@ -2198,3 +2346,214 @@ void uwsgi_string_del_list(struct uwsgi_string_list **list, struct uwsgi_string_
 	}
 	
 }
+
+void uwsgi_sig_pause() {
+
+	sigset_t mask;
+        sigemptyset(&mask);
+	sigsuspend(&mask);
+}
+
+int uwsgi_run_command_and_wait(char *command, char *arg) {
+
+	char *argv[3];
+	int waitpid_status = 0;
+	pid_t pid = fork();
+	if (pid < 0) {
+		return -1;
+	}
+	
+	if (pid > 0) {
+		if (waitpid(pid, &waitpid_status, 0) < 0) {
+			uwsgi_error("waitpid()");
+			return -1;
+		}
+
+		return WEXITSTATUS(waitpid_status);
+	}
+
+	argv[0] = command;
+	argv[1] = arg;
+	argv[2] = NULL;
+
+	execvp(command, argv);
+
+	uwsgi_error("execvp()");
+	//never here
+	exit(1);
+}
+
+int uwsgi_run_command(char *command) {
+
+	char *argv[4];
+
+        int waitpid_status = 0;
+        pid_t pid = fork();
+        if (pid < 0) {
+                return -1;
+        }
+
+        if (pid > 0) {
+                if (waitpid(pid, &waitpid_status, WNOHANG) < 0) {
+                        uwsgi_error("waitpid()");
+                        return -1;
+                }
+
+                return WEXITSTATUS(waitpid_status);
+        }
+
+	uwsgi_close_all_sockets();
+
+	if (setsid() < 0) {
+		uwsgi_error("setsid()");
+		exit(1);
+	}
+
+	argv[0] = "/bin/sh";
+	argv[1] = "-c";
+	argv[2] = command;
+	argv[3] = NULL;
+
+        execvp("/bin/sh", argv);
+
+        uwsgi_error("execvp()");
+        //never here
+        exit(1);
+}
+
+int *uwsgi_attach_fd(int fd, int count, char *code, size_t code_len) {
+
+	struct msghdr   msg;
+	ssize_t len;
+	char *id = NULL;
+
+	struct iovec iov;
+	struct cmsghdr *cmsg;
+	int *ret;
+	int i;
+
+	void *msg_control = uwsgi_malloc(CMSG_SPACE(sizeof(int) * count));
+	
+	memset( msg_control, 0, CMSG_SPACE(sizeof(int) * count));
+
+	if (code && code_len > 0) {
+		id = uwsgi_malloc(code_len);
+		memset(id, 0, code_len);
+	}
+
+	iov.iov_base = id;
+        iov.iov_len = code_len;
+        memset(&msg, 0, sizeof(msg));
+
+	msg.msg_name = NULL;
+        msg.msg_namelen = 0;
+        msg.msg_iov = &iov;
+        msg.msg_iovlen = 1;
+        msg.msg_control = msg_control;
+        msg.msg_controllen = CMSG_SPACE(sizeof(int) * count);
+        msg.msg_flags = 0;
+
+        len = recvmsg(fd, &msg, 0);
+	if (len <= 0) {
+		uwsgi_error("recvmsg()");
+		return NULL;
+	}
+	
+	if (code && code_len > 0) {
+		if (strcmp(id, code)) {
+			return NULL;
+		}
+	}
+	
+	cmsg = CMSG_FIRSTHDR(&msg);
+	if (!cmsg) return NULL;
+
+	if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
+		return NULL;
+	}
+
+	if ((size_t) (cmsg->cmsg_len - ((char *)CMSG_DATA(cmsg)- (char *)cmsg)) > (size_t) (sizeof(int) * (count + 1))) {
+        	uwsgi_log("not enough space for sockets data, consider increasing it\n");
+        	return NULL;
+	}
+
+	ret = uwsgi_malloc(sizeof(int) * (count + 1));
+	for(i=0;i<count+1;i++) {
+		ret[i] = -1;
+	}
+
+	memcpy(ret, CMSG_DATA(cmsg), cmsg->cmsg_len - ((char *)CMSG_DATA(cmsg)- (char *)cmsg));
+
+	free(msg_control);
+	if (code && code_len > 0) {
+		free(id);
+	}
+
+	return ret;
+}
+
+int uwsgi_endswith(char *str1, char *str2) {
+
+	size_t i;
+	size_t str1len = strlen(str1);
+	size_t str2len = strlen(str2);
+	char *ptr;
+
+	if (str2len > str1len) return 0;
+	
+	ptr = (str1 + str1len) - str2len;
+
+	for(i=0;i<str2len;i++) {
+		if (*ptr != str2[i]) return 0;
+		ptr++;
+	}
+
+	return 1;
+}
+
+void uwsgi_chown(char *filename, char *owner) {
+
+	uid_t new_uid = -1;
+	uid_t new_gid = -1;
+	struct group *new_group = NULL;
+	struct passwd *new_user = NULL;
+
+	char *colon = strchr(owner, ':');
+	if (colon) {
+		colon[0] = 0;
+	}
+
+	
+	if (is_a_number(owner)) {
+		new_uid = atoi(owner);
+	}
+	else {
+		new_user = getpwnam(owner);
+		if (!new_user) {
+			uwsgi_log("unable to find user %s\n", owner);
+			exit(1);
+		}
+		new_uid = new_user->pw_uid;
+	}
+
+	if (colon) {
+		colon[0] = ':';
+		if (is_a_number(colon+1)) {
+			new_gid = atoi(colon+1);
+		}
+		else {
+			new_group = getgrnam(colon+1);
+			if (!new_group) {
+				uwsgi_log("unable to find group %s\n", colon+1);
+				exit(1);
+			}
+			new_gid = new_group->gr_gid;
+		}
+	}
+
+	if (chown(filename, new_uid, new_gid)) {
+		uwsgi_error("chown()");
+		exit(1);
+	}
+
+}

uwsgi_API.txt

@@ -20,7 +20,7 @@ unlock()
 send()
 cl()
 req_fd()
-signal(num,[payload])
+signal(num)
 sendfile()
 set_warning_message()
 mem()
@@ -50,6 +50,6 @@ sharedarea_writebyte
 sharedarea_readlong
 sharedarea_writelong
 sharedarea_inclong
-register_signal(num, handler)
+register_signal(num, targer, handler)
 register_rpc(name, func[,args])
 rpc(node, name[,args,...])

uwsgicc/__init__.py

@@ -1,3 +1,12 @@
 from uwsgicc import app
 
+import uwsgi
+
+def hello_world(name):
+    return "Hello World %s" % name
+
+uwsgi.register_rpc("hello", hello_world)
+
+uwsgi.set_warning_message("uWSGI is running the Control Center")
+
 application = app

uwsgicc/templates/index.html

@@ -152,7 +152,7 @@ $(document).ready(function() {
 	});
 
 	$('#rpc_form').submit(function() {
-		$.post('{{url_for('rpc')}}', { node: '192.168.173.100:3031', func: 'hello', args: ''}, function(data) {
+		$.post('{{url_for('rpc')}}', { node: $('[name=node]').val(), func: $('[name=func]').val(), args: $('[name=args]').val()}, function(data) {
 			$('#dialog-modal').html(data);
 			$('#dialog-modal').attr('title', 'RPC "hello" returned:');
 			$('#dialog-modal').dialog({
@@ -174,7 +174,7 @@ $(document).ready(function() {
 <a name="top"></a>
 <h1>uWSGI <span class="small">{{uwsgi.version}}</span> Control Center</h1>
 <div class="anchor">
-<a href="#information">information</a> | <a href="#options">options</a> | <a href="#logs">logs</a> | <a href="#workers">workers</a> | <a href="#rpc">rpc</a> {% if uwsgi.cluster() %}| <a href="#cluster">cluster</a>{% endif %}
+<a href="#information">information</a> | <a href="#options">options</a> | <a href="#logs">logs</a> | <a href="#signals">signals</a> | <a href="#workers">workers</a> | <a href="#rpc">rpc</a> {% if uwsgi.cluster() %}| <a href="#cluster">cluster</a>{% endif %}
 </div>
 
 {% with messages = get_flashed_messages() %}
@@ -204,6 +204,13 @@ $(document).ready(function() {
 <b>cores:</b> {{ uwsgi.cores }}<br/>
 <b>masterpid:</b> {{uwsgi.masterpid()}}<br/>
 <b>cluster:</b> {{uwsgi.cluster()}}<br/>
+{% if uwsgi.opt['spooler'] %}
+<b>spooler pid:</b> {{uwsgi.spooler_pid()}}<br/>
+{% endif %}
+
+{% if uwsgi.has_threads == 1 %}
+<b>--- threads enabled ---</b><br/>
+{% endif %}
 
     <div class="anchor">
     <a href="#top">back to top</a>
@@ -239,6 +246,21 @@ $(document).ready(function() {
 
 </div>
 
+<a name="signals"></a>
+<h3>Signals</h3>
+<div class="info">
+<form action="{{url_for('sig')}}" method="POST">
+        <input type="text" size="3" name="signum" />
+        <input type="submit" value="send uwsgi signal" />
+</form>
+
+    <div class="anchor">
+    <a href="#top">back to top</a>
+    </div>
+
+</div>
+
+
 <a name="workers"></a>
 <h3>Workers</h3>
 <div class="info">

uwsgicc/uwsgicc.py

@@ -23,16 +23,24 @@ def log():
     flash("log message written")
     return redirect(url_for('index'))
 
+@app.route("/sig", methods=['POST'])
+def sig():
+    try:
+        uwsgi.signal(int(request.form['signum']))
+        flash("uwsgi signal sent")
+    except:
+        flash("unable to send signal")
+    return redirect(url_for('index'))
+
 @app.route("/rpc", methods=['POST'])
 def rpc():
     node = str(request.form['node'])
-    if node == '':
-	node = None
 
     fargs = str(request.form['args'])
 
     args = fargs.split()
 
+
     if len(args) > 0:
         ret = uwsgi.rpc(str(node), str(request.form['func']), *map(str, args))
     else:

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '0.9.8-dev'
+uwsgi_version = '0.9.8.2'
 
 import os
 import re
@@ -25,8 +25,10 @@ GCC = os.environ.get('CC', sysconfig.get_config_var('CC'))
 if not GCC:
     GCC = 'gcc'
 
+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'))
@@ -63,8 +65,26 @@ def add_o(x):
     return x
 
 
-def compile(file, objfile, cflags):
-    cmdline = "%s -c %s -o %s %s" % (GCC, cflags, objfile, file)
+def compile(cflags, objfile, srcfile):
+    source_stat = os.stat(srcfile)
+    header_stat = os.stat('uwsgi.h')
+    try:
+        if os.environ.get('UWSGI_FORCE_REBUILD', None):
+            raise
+        object_stat = os.stat(objfile)
+        if object_stat[8] <= source_stat[8]:
+            raise
+        if object_stat[8] <= header_stat[8]:
+            raise
+        for profile in os.listdir('buildconf'):
+            profile_stat = os.stat('buildconf/%s' % profile)
+            if object_stat[8] <= profile_stat[8]:
+                raise
+        print("%s is up to date" % objfile)
+        return
+    except:
+        pass
+    cmdline = "%s -c %s -o %s %s" % (GCC, cflags, objfile, srcfile)
     print(cmdline)
     ret = os.system(cmdline)
     if ret != 0:
@@ -146,6 +166,11 @@ def build_uwsgi(uc):
 
     bin_name = uc.get('bin_name')
 
+    if uc.get('embed_config'):
+        gcc_list.append(uc.get('embed_config'))
+    for ef in binary_list:
+        gcc_list.append("build/%s" % ef)
+
     print("*** uWSGI linking ***")
     ldline = "%s -o %s %s %s %s" % (GCC, bin_name, ' '.join(ldflags),
         ' '.join(map(add_o, gcc_list)), ' '.join(libs))
@@ -166,7 +191,7 @@ class uConf(object):
         self.config = ConfigParser.ConfigParser()
         print("using profile: %s" % filename)
         self.config.read(filename)
-        self.gcc_list = ['utils', 'protocol', 'socket', 'logging', 'master', 'emperor', 'notify',
+        self.gcc_list = ['utils', 'protocol', 'socket', 'logging', 'master', 'master_utils', 'emperor', 'notify',
             'plugins', 'lock', 'cache', 'queue', 'event', 'signal', 'rpc', 'gateway', 'loop', 'lib/rbtree', 'lib/amqp', 'rb_timers', 'uwsgi']
         # add protocols
         self.gcc_list.append('proto/base')
@@ -176,7 +201,7 @@ class uConf(object):
         if uwsgi_os == 'Linux':
             self.gcc_list.append('lib/linux_ns')
             self.gcc_list.append('lib/netlink')
-        self.cflags = ['-DUWSGI_VERSION="\\"' + uwsgi_version + '\\""', '-O2', '-Wall', '-Werror', '-D_LARGEFILE_SOURCE', '-D_FILE_OFFSET_BITS=64'] + os.environ.get("CFLAGS", "").split()
+        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:
@@ -207,12 +232,13 @@ class uConf(object):
             iconfig = ConfigParser.ConfigParser()
             iconfig.read(inherit)
             for opt in iconfig.options('uwsgi'):
-                if not self.get(opt):
+                if not self.config.has_option('uwsgi', opt):
                     self.set(opt, iconfig.get('uwsgi', opt))
-                elif self.get(opt).startswith('+'):
-                    self.set(opt, iconfig.get('uwsgi', opt) + self.get(opt)[1:])
-                elif self.get(opt) == 'null':
-                    self.config.remove_option('uwsgi', opt)
+                elif self.get(opt):
+                    if self.get(opt).startswith('+'):
+                        self.set(opt, iconfig.get('uwsgi', opt) + self.get(opt)[1:])
+                    elif self.get(opt) == 'null':
+                        self.config.remove_option('uwsgi', opt)
 
 
     def set(self, key, value):
@@ -237,12 +263,18 @@ class uConf(object):
 
     def get_gcll(self):
 
+        global uwsgi_version
+
         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'):
+            self.cflags.append('-DUWSGI_HAS_IFADDRS')
+
         if uwsgi_os == 'SunOS':
             self.libs.append('-lsendfile')
             self.gcc_list.append('lib/sun_fixes')
+            self.ldflags.append('-L/lib')
             if not uwsgi_os_v.startswith('Nexenta'):
                 self.libs.remove('-rdynamic')
 
@@ -404,6 +436,83 @@ class uConf(object):
             if os.path.exists('/usr/lib/libuuid.so') or os.path.exists('/usr/local/lib/libuuid.so'):
                 self.libs.append('-luuid')
 
+        if self.get('append_version'):
+            if not self.get('append_version').startswith('-'):
+                uwsgi_version += '-'
+            uwsgi_version += self.get('append_version')
+
+
+
+        if uwsgi_os == 'Linux':
+            if self.get('embed_config'):
+                binary_link_cmd = "ld -r -b binary -o %s.o %s" % (self.get('embed_config'), self.get('embed_config'))
+                print(binary_link_cmd)
+                os.system(binary_link_cmd)
+                self.cflags.append("-DUWSGI_EMBED_CONFIG=_binary_%s_start" % self.get('embed_config').replace('.','_'))
+                self.cflags.append("-DUWSGI_EMBED_CONFIG_END=_binary_%s_end" % self.get('embed_config').replace('.','_'))
+            if self.get('embed_files'):
+                for ef in self.get('embed_files').split(','):
+                    ef_parts = ef.split('=')
+                    symbase = None
+                    if len(ef_parts) > 1:
+                        ef = ef_parts[1]
+                        symbase = ef_parts[0]
+                    if os.path.isdir(ef):
+                        for directory, directories, files in os.walk(ef):
+                            for f in files:
+                                fname = "%s/%s" % (directory, f)
+                                binary_link_cmd = "ld -r -b binary -o build/%s.o %s" % (binarize(fname), fname)
+                                print(binary_link_cmd)
+                                os.system(binary_link_cmd)
+                                if symbase:
+                                    for kind in ('start','end'):
+                                        objcopy_cmd = "objcopy --redefine-sym _binary_%s_%s=_binary_%s%s_%s build/%s.o" % (binarize(fname), kind, binarize(symbase), binarize(fname[len(ef):]), kind, binarize(fname))
+                                        print(objcopy_cmd)
+                                        os.system(objcopy_cmd)
+                                binary_list.append(binarize(fname))
+                    else:
+                        binary_link_cmd = "ld -r -b binary -o build/%s.o %s" % (binarize(ef), ef)
+                        print(binary_link_cmd)
+                        os.system(binary_link_cmd)
+                        binary_list.append(binarize(ef))
+                        if symbase:
+                            for kind in ('start','end'):
+                                objcopy_cmd = "objcopy --redefine-sym _binary_%s_%s=_binary_%s_%s build/%s.o" % (binarize(ef), kind, binarize(symbase), kind, binarize(ef))
+                                print(objcopy_cmd)
+                                os.system(objcopy_cmd)
+                
+                 
+
+        self.cflags.append('-DUWSGI_VERSION="\\"' + uwsgi_version + '\\""')
+
+        uver_whole = uwsgi_version.split('-', 1)
+        if len(uver_whole) == 1:
+            uver_custom = ''
+        else:
+            uver_custom = uver_whole[1]
+
+        uver_dots = uver_whole[0].split('.')
+
+        uver_base = uver_dots[0]
+        uver_maj = uver_dots[1]
+        uver_min = '0'
+        uver_rev = '0'
+
+        if len(uver_dots) > 2:
+            uver_min = uver_dots[2]
+
+        if len(uver_dots) > 3:
+            uver_rev = uver_dots[3]
+        
+
+        self.cflags.append('-DUWSGI_VERSION_BASE="' + uver_base + '"')
+        self.cflags.append('-DUWSGI_VERSION_MAJOR="' + uver_maj + '"')
+        self.cflags.append('-DUWSGI_VERSION_MINOR="' + uver_min + '"')
+        self.cflags.append('-DUWSGI_VERSION_REVISION="' + uver_rev + '"')
+        self.cflags.append('-DUWSGI_VERSION_CUSTOM="\\"' + uver_custom + '\\""')
+
+	
+
         if self.get('async'):
             self.cflags.append("-DUWSGI_ASYNC")
             self.gcc_list.append('async')
@@ -569,7 +678,10 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
         shared_flag = '-dynamiclib -undefined dynamic_lookup'
 
     for cfile in up.GCC_LIST:
-        gcc_list.append(path + '/' + cfile + '.c')
+        if not cfile.endswith('.c') and not cfile.endswith('.cc'):
+            gcc_list.append(path + '/' + cfile + '.c')
+        else:
+            gcc_list.append(path + '/' + cfile)
 
 
     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) )
@@ -618,7 +730,6 @@ if __name__ == "__main__":
             pass
         if not '/' in bconf:
             bconf = 'buildconf/%s' % bconf
-
         uc = uConf(bconf)
         gcc_list, cflags, ldflags, libs = uc.get_gcll()
         try:
@@ -626,6 +737,13 @@ if __name__ == "__main__":
         except:
             name = None
         build_plugin(sys.argv[2], uc, cflags, ldflags, libs, name)
+    elif cmd == '--clean':
+        os.system("rm -f *.o")
+        os.system("rm -f proto/*.o")
+        os.system("rm -f lib/*.o")
+        os.system("rm -f plugins/*/*.o")
+        os.system("rm -f build/*.o")
+
     else:
         print("unknown uwsgiconfig command")
         sys.exit(1)

uwsgidecorators.py

@@ -0,0 +1,173 @@
+import uwsgi
+from threading import Thread
+
+if uwsgi.masterpid() == 0:
+    raise Exception("you have to enable the uWSGI master process to use this module")
+
+if uwsgi.opt.get('lazy'):
+    raise Exception("uWSGI lazy mode is not supporte by this module")
+
+spooler_functions = {}
+postfork_chain = []
+
+def get_free_signal():
+    for signum in xrange(0, 256):
+        if not uwsgi.signal_registered(signum):
+            return signum
+
+    raise Exception("No free uwsgi signal available")
+
+def manage_spool_request(vars):
+    ret = spooler_functions[vars['ud_spool_func']](vars)
+    if not vars.has_key('ud_spool_ret'):
+        return ret
+    return int(vars['ud_spool_ret'])
+
+def postfork_chain_hook():
+    for f in postfork_chain:
+        f()
+
+uwsgi.spooler = manage_spool_request
+uwsgi.post_fork_hook = postfork_chain_hook
+
+class postfork(object):
+    def __init__(self, f):
+        postfork_chain.append(f)
+
+class spool(object):
+
+    def spool(self, *args, **kwargs):
+        arguments = self.base_dict
+        arguments['ud_spool_ret'] = str(uwsgi.SPOOL_OK)
+        if len(args) > 0:
+            arguments.update(args[0])
+        if kwargs:
+            arguments.update(kwargs)
+        return uwsgi.spool(arguments)
+
+    def __init__(self, f):
+        if not uwsgi.opt.has_key('spooler'):
+            raise Exception("you have to enable the uWSGI spooler to use the @spool decorator")
+        self.f = f
+        spooler_functions[f.__name__] = self.f
+        self.f.spool = self.spool
+	self.base_dict = {'ud_spool_func':self.f.__name__}
+
+class spoolforever(spool):
+
+    def spool(self, *args, **kwargs):
+        arguments = self.base_dict
+        arguments['ud_spool_ret'] = str(uwsgi.SPOOL_RETRY)
+        if len(args) > 0:
+            arguments.update(args[0])
+        if kwargs:
+            arguments.update(kwargs)
+        return uwsgi.spool(arguments)
+
+class spoolraw(spool):
+
+    def spool(self, *args, **kwargs):
+        arguments = self.base_dict
+        if len(args) > 0:
+            arguments.update(args[0])
+        if kwargs:
+            arguments.update(kwargs)
+        return uwsgi.spool(arguments)
+
+
+class rpc(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __call__(self, f):
+        uwsgi.register_rpc(self.name, f)
+        return f
+
+class signal(object):
+
+    def __init__(self, num, **kwargs):
+        self.num = num
+	self.target = kwargs.get('target', '')
+
+    def __call__(self, f):
+        uwsgi.register_signal(self.num, self.target, f)
+        return f
+
+class timer(object):
+
+    def __init__(self, secs, **kwargs):
+        self.num = kwargs.get('signum', get_free_signal())
+        self.secs = secs
+	self.target = kwargs.get('target', '')
+
+    def __call__(self, f):
+        uwsgi.register_signal(self.num, self.target, f)
+        uwsgi.add_timer(self.num, self.secs)
+        return f
+
+class cron(object):
+
+    def __init__(self, minute, hour, day, month, dayweek, **kwargs):
+        self.num = kwargs.get('signum', get_free_signal())
+        self.minute = minute
+        self.hour = hour
+        self.day = day
+        self.month = month
+        self.dayweek = dayweek
+	self.target = kwargs.get('target', '')
+
+    def __call__(self, f):
+        uwsgi.register_signal(self.num, self.target, f)
+        uwsgi.add_cron(self.num, self.minute, self.hour, self.day, self.month, self.dayweek)
+        return f
+
+
+
+class rbtimer(object):
+
+    def __init__(self, secs, **kwargs):
+        self.num = kwargs.get('signum', get_free_signal())
+        self.secs = secs
+	self.target = kwargs.get('target', '')
+
+    def __call__(self, f):
+        uwsgi.register_signal(self.num, self.target, f)
+        uwsgi.add_rb_timer(self.num, self.secs)
+        return f
+
+class filemon(object):
+
+    def __init__(self, fsobj, **kwargs):
+        self.num = kwargs.get('signum', get_free_signal())
+        self.fsobj = fsobj
+	self.target = kwargs.get('target', '')
+
+    def __call__(self, f):
+        uwsgi.register_signal(self.num, self.target, f)
+        uwsgi.add_file_monitor(self.num, self.fsobj)
+        return f
+
+class lock(object):
+    def __init__(self, f):
+        self.f = f
+
+    def __call__(self, *args, **kwargs):
+        uwsgi.lock()
+        try:
+            return self.f(*args, **kwargs)
+        finally:
+            uwsgi.unlock()
+
+class thread(object):
+
+    def __init__(self, f):
+        self.f = f
+
+    def __call__(self, *args):
+        t = Thread(target=self.f, args=args)
+        t.daemon = True
+        t.start()
+        return self.f
+
+    

vassals/broodlord.ini

@@ -0,0 +1,19 @@
+[uwsgi]
+
+socket = :3031
+master = true
+vassal-sos-backlog = 10
+module = werkzeug.testapp:test_app
+processes = 1
+zerg-server = /tmp/broodlord.sock
+disable-logging = true
+
+
+[zerg]
+zerg = /tmp/broodlord.sock
+master = true
+module = werkzeug.testapp:test_app
+processes = 1
+disable-logging = true
+idle = 30
+die-on-idle = true

vassals/cc.ini

@@ -3,6 +3,7 @@
 trac = trac.web.main
 id = myapp
 socket = /tmp/%(id).sock
+socket = :0
 env = TRAC_ENV=/opt/projects/%(id)
 module = %(trac):dispatch_request
 processes = 8

vhosttest/flask001/app1.py

@@ -0,0 +1,6 @@
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello World!"

vhosttest/flask002/app2.py

@@ -0,0 +1,6 @@
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello World! app2 !!!"

vhosttest/flask003/app3.py

@@ -0,0 +1,6 @@
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello World! app3"

vhosttest/flask004/app4.py

@@ -0,0 +1,6 @@
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello World! app4"

vhosttest/flask005/app5.py

@@ -0,0 +1,6 @@
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/")
+def hello():
+    return "Hello World! app5"