uWSGI 0.9.8.3

.hgignore

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

.hgtags

@@ -9,3 +9,21 @@ b8f67c6cd0d62f864db9b2b265b4e260ad7d873c 0.9.6-rc2
 35918dd4b3771158b2b57410613ef029e08bbd60 0.9.6
 5f25d1f97f9dde3e391a668c1c610a52a5db8244 0.9.6.1
 ef31fc61ac48018c464f28ebfdf865b96bf83f18 0.9.6.2
+9e100c1f085034396cec586f0c76ad3f9800d1a5 0.9.7-beta1
+ff4111eb8f55b958ec91c70163e10f3372a9b94d 0.9.7-rc1
+eb8aff2926230bb114fb90f67203440a2c534bf1 0.9.7-rc2
+311eef929ec8fd0a5dc8c16531afb7bb42d36d01 0.9.7-rc3
+4b50c04e414f1d9ab8b0b5910aba83d09ac21abb 0.9.7
+d9b9b540f7dce8cb05d2e61ca8b4d75f2ea25f62 0.9.7.1
+d9b9b540f7dce8cb05d2e61ca8b4d75f2ea25f62 0.9.7.1
+0000000000000000000000000000000000000000 0.9.7.1
+0000000000000000000000000000000000000000 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
+7169ef1d68d3dab4737bcc3f9e082839e5a06cc1 0.9.8.2

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,8 +1,251 @@
+*** july 2011 ***
+
+ * 0.9.8.3 [20110723]
+
+- implemented uwsgi.SymZipImporter to load embedded zip files
+- OSX Lion is officially supported
+- fixed xinetd support (example file added in contrib)
+- suppot for systemd socket activation
+- added --freebind option (Linux only)
+
+ * 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
+- added vassals loyalty concept
+- fixed virtualhosting with dynamic virtualenv
+- fixed reloading on grand-central-dispatch-enabled OSX
+- improved PSGI support with uGreen and async support
+- improved Rack support with complete fiber+async in ruby 1.9
+- support for JSON config files
+- native multi-protocol support (added fastcgi and http)
+- Mongrel2 support
+- support for templates in vassals
+- various threading fixes
+- gcc-4.6 support
+- support for logging via zeromq
+- support for configuration passed via pipe/stdin
+- pythonpath entries are now unlimited
+- socket entries are unlimited
+- pythonpath can be a glob
+- lazy mode added
+- new language-independent profiling subsystem
+- support for configuration stored in a sqlite3 db
+- allow workers to survive to syslogd death (when --log-syslog is used)
+- fix traceback in Python 3.x
+- support for uwsgi signals in threads
+- plugin autoloading
+- graceful reloading for threads
+- new wsgi.input object
+- support for alternative allocators (tcmalloc and jemalloc)
+
+
+*** april 2011 ***
+
+ * 0.9.7.2 [20110406]
+
+- new option --touch-reload <file> to reload the stack on <file> modification
+--static-map <mountpoint=documentroot> allows to serve static files
+- fixed --post-limit management
+- disallow empty socket names
+- implemented exception_info WSGI support
+- new options --reload-on-as <n> and --reload-on-rss <n> allows
+to recycle workers when their memory usage is higher than <n> MB
+- fixed syslog support (use --log-syslog[=facility] to enable it)
+- improved plugin loading system
+- added support for RabbitMQ as event dispatcher for the Emperor
+- fixed FreeBSD memory report
+- PSGI plugin can be compiled without ithreads
+- various Emperor fixes
+- fixed a regression with setgroups()
+- support for shared sockets (used in jails within network namespaces)
+
 *** march 2011 ***
 
+ * 0.9.7.1 [20110326]
+
+- fixed python stackless support
+- added persistence for queue
+- forbid daemonizing in vassal mode
+- modifier1 30 is available again
+- allow python modules to be mapped/aliased via http
+- added --pidfile2 and --logfile-chown
+- added UWSGI_CACHE_GET dynamic variable
+- 304/If-Modified-Since support for --check-static
+- option --check-cache for integrated caching
+- option --map-socket to assign specific workers to socket
+- fixed unix fd passing on older OSX versions
+- fixed post-buffering without pep3333-input
+- fixed python threading without uwsgi cores
+- support for Linux network namespace
+- build with sys.abiflags if necessary
+
+
+ * 0.9.7 [20110317]
+
+- fixed psgi compilation on GNU systems
+- improved --pep3333-input
+- better error reporting on failed open/fopen
+- fixed uGreen
+- added greenlet support
+- various solaris fixes
+- new help system
+- updated async support
+- fixed uwsgi.cache_get in python
+
+ * 0.9.7-rc3 [20110312]
+
+- added support for persistent cache (--cache-store <filename>)
+- less verbose file monitoring
+- fixed a race condition in emperor startup
+- fixed erlang empty list encoding
+- improved snmp support
+- fixed cache modifier 111 for 3 and 4
+- preliminary cpu-affinity support (Linux only)
+- fixed ldap support
+- auto-configure ldap compilation
+- added --allowed-modifiers (allow only a subset of modifiers)
+- fixed a bug with getopt_long
+
+ * 0.9.7-rc2 [20110309]
+
+- added cron-like interface to signal framework
+- improved Linux namespaces support
+- fixed multithreading + --max-requests
+- added support for reference in configuration files
+
+ * 0.9.7-rc1 [20110307]
+
+- export %v in emperor mode
+- fixed signal race condition in server reload
+- fixed http router post handling bug
+- added uwsgi.erlang_register_process in pyerl plugin
+- fixed unix socket inherit
+- fixed linux namespace support in recent kernel/gcc
+- ported threading to python 3.2
+- add build date to uWSGI startup info
+- do not allow clustering without defining a socket
+- kill all the gateways/daemons on startup errors
+- fixed vacuum after chdir()
+- fixed gateways reload
+- re-added support for OpenBSD and NetBSD
+- fixed post-buffering in python
+- use erlang binary for python string
+- fixed memory leak in pyerl plugin
+- removed broken log rotation (post-poned)
+- fixed no_argument options in ini and yaml parsing
+
  * 0.9.7-beta1 [20110301]
 
 - fully modular re-design
+- advanced build system with presets
 - threading support
 - emperor mode for massive auto-hosting
 - caching subsystem

Makefile

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

async.c

@@ -2,198 +2,431 @@
 
 extern struct uwsgi_server uwsgi;
 
-int async_get_timeout() {
-
-        struct wsgi_request* wsgi_req ;
-        int i ;
-	time_t curtime, tdelta = 0 ;
-	int ret = 0 ;
-
-	// do not wait if there are cores running
-	if (!uwsgi.async_running) return 0;
-
-        for(i=0;i<uwsgi.async_current_max;i++) {
-		wsgi_req = uwsgi.wsgi_requests[i];
-                if (wsgi_req->async_status == UWSGI_AGAIN) {
-			if (wsgi_req->async_timeout_expired) {
-				// do not wait if there are timeout expired
-				return 0;
-			}
-			if (wsgi_req->async_timeout > 0) {
-				if (tdelta <= 0 || tdelta > wsgi_req->async_timeout) {
-					tdelta = wsgi_req->async_timeout ;
-				}
-			}
-                }
-        }
-
-	curtime = time(NULL);
-
-	ret = tdelta - curtime ;
-	if (ret > 0) {
-		return ret;
-	}
-	
-	return -1;
+struct wsgi_request *find_wsgi_req_proto_by_fd(int fd) {
+	return uwsgi.async_proto_fd_table[fd];
 }
 
-void async_expire_timeouts() {
+struct wsgi_request *find_wsgi_req_by_fd(int fd) {
+	return uwsgi.async_waiting_fd_table[fd];
+}
 
-        struct wsgi_request* wsgi_req ;
-        int i ;
-	time_t deadline = time(NULL);
+void runqueue_remove(struct uwsgi_async_request *u_request) {
 
-
-        for(i=0;i<uwsgi.async_current_max;i++) {
-                wsgi_req = uwsgi.wsgi_requests[i] ;
-
-                if (wsgi_req->async_status == UWSGI_AGAIN && wsgi_req->async_timeout > 0) {
-			if (wsgi_req->async_timeout <= deadline) {
-				wsgi_req->async_timeout = 0 ;
-				wsgi_req->async_timeout_expired = 1 ;
-				if (wsgi_req->async_waiting_fd != -1) {
-                                        event_queue_del_fd(uwsgi.async_queue, wsgi_req->async_waiting_fd);
-					uwsgi.async_waiting_fd_table[wsgi_req->async_waiting_fd] = -1;
-                                        wsgi_req->async_waiting_fd = -1;
-                                        wsgi_req->async_waiting_fd_monitored = 0;
-                                }
-			}	
-                }
+	struct uwsgi_async_request *parent = u_request->prev;
+	struct uwsgi_async_request *child = u_request->next;
+	
+        if (parent) {
+        	parent->next = child;
         }
+        if (child) {
+        	child->prev = parent;
+        }
+
+        if (parent == NULL) {
+        	uwsgi.async_runqueue = child;
+        }
+
+	if (u_request == uwsgi.async_runqueue_last) {
+		uwsgi.async_runqueue_last = parent;
+	}
+
+        free(u_request);
+
+	uwsgi.async_runqueue_cnt--;
+}
+
+void runqueue_push(struct wsgi_request *wsgi_req) {
+
+	struct uwsgi_async_request *uar;
+
+	if (uwsgi.async_runqueue == NULL) {
+        	// empty runqueue, create a new one
+        	uwsgi.async_runqueue = uwsgi_malloc(sizeof(struct uwsgi_async_request));
+        	uwsgi.async_runqueue->next = NULL;
+        	uwsgi.async_runqueue->prev = NULL;
+        	uwsgi.async_runqueue->wsgi_req = wsgi_req;
+        	uwsgi.async_runqueue_last = uwsgi.async_runqueue;
+        }
+        else {
+		uar = uwsgi_malloc(sizeof(struct uwsgi_async_request));
+        	uar->prev = uwsgi.async_runqueue_last;
+        	uar->next = NULL;
+        	uar->wsgi_req = wsgi_req;
+        	uwsgi.async_runqueue_last->next = uar;
+        	uwsgi.async_runqueue_last = uar;
+        }
+
+	uwsgi.async_runqueue_cnt++;
+
 }
 
 struct wsgi_request *find_first_available_wsgi_req() {
 
-        struct wsgi_request* wsgi_req;
-        int i ;
+	struct wsgi_request *wsgi_req;
 
-	// optimization
-	if (uwsgi.async_current_max > 1) {
-		if (uwsgi.wsgi_requests[uwsgi.async_current_max-1]->async_status == UWSGI_OK) {
-			//uwsgi_log("decreasing current max cores\n");
-			uwsgi.async_current_max--;
-		}
+	if (uwsgi.async_queue_unused_ptr < 0) {
+		return NULL;
 	}
 
-        for(i=0;i<uwsgi.async;i++) {
-                wsgi_req = uwsgi.wsgi_requests[i] ;
-                if (wsgi_req->async_status == UWSGI_OK) {
-			// optimization
-			if (i > uwsgi.async_current_max-1) uwsgi.async_current_max = i+1;
-			wsgi_req->async_id = i;
-                        return wsgi_req ;
+	wsgi_req = uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr];
+	uwsgi.async_queue_unused_ptr--;
+	return wsgi_req;
+}
+
+void async_expire_timeouts() {
+
+	struct wsgi_request *wsgi_req;
+	time_t current_time = time(NULL);
+	struct uwsgi_async_fd *uaf = NULL, *current_uaf;
+
+	struct uwsgi_rb_timer *urbt;
+
+        for(;;) {
+
+                urbt = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts);
+
+                if (urbt == NULL) return;
+
+                if (urbt->key <= current_time) {
+                        wsgi_req = (struct wsgi_request *) urbt->data;
+			// timeout expired
+			wsgi_req->async_timed_out = 1;
+			rb_erase(&wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+			free(wsgi_req->async_timeout);
+			wsgi_req->async_timeout = NULL;
+			uaf = wsgi_req->waiting_fds;
+			// remove fds from monitoring (no problem modifying the queue here, as the function is executed only when there are no fd ready)
+			while(uaf) {
+				event_queue_del_fd(uwsgi.async_queue, uaf->fd, uaf->event);
+				uwsgi.async_waiting_fd_table[uaf->fd] = NULL;
+				current_uaf = uaf;
+				uaf = current_uaf->next;
+				free(current_uaf);
+			}
+			wsgi_req->waiting_fds = NULL;
+			// put th request in the runqueue
+			runqueue_push(wsgi_req);
+                        continue;
                 }
+
+                break;
         }
 
-        return NULL ;
 }
 
-struct wsgi_request *find_wsgi_req_by_fd(int fd) {
+void async_add_fd_read(struct wsgi_request *wsgi_req, int fd, int timeout) {
 
-        struct wsgi_request* wsgi_req = NULL ;
-	int core_id = uwsgi.async_waiting_fd_table[fd];
+	struct uwsgi_async_fd *last_uad = NULL, *uad = wsgi_req->waiting_fds;
 
-	if (core_id == -1) return NULL;
+	if (fd < 0) return ;
 
-	wsgi_req = uwsgi.wsgi_requests[core_id];
-        //if (wsgi_req->async_waiting_fd_type == etype) return wsgi_req ;
-	return wsgi_req;
+	// find first slot
+	while(uad) {
+		last_uad = uad;
+		uad = uad->next;
+	}
 
-        return NULL ;
+	uad = uwsgi_malloc(sizeof(struct uwsgi_async_fd));
+	uad->fd = fd;
+	uad->event = event_queue_read();
+	uad->prev = last_uad;
+	uad->next = NULL;
 
-}
+	if (last_uad) {
+		last_uad->next = uad;
+	}
+	else {
+		wsgi_req->waiting_fds = uad;
+	}
 
-void async_set_timeout(struct wsgi_request *wsgi_req, time_t timeout) {
-
-	wsgi_req->async_timeout = time(NULL);
-	wsgi_req->async_timeout += timeout;
-	wsgi_req->async_timeout_expired = 0 ;
+	if (timeout > 0) {
+		async_add_timeout(wsgi_req, timeout);
+	}
+	uwsgi.async_waiting_fd_table[fd] = wsgi_req;
+	event_queue_add_fd_read(uwsgi.async_queue, fd);
 	
 }
 
-void async_write_all(char *data, size_t len) {
-	
-	struct wsgi_request *wsgi_req;
-	int i;
-	ssize_t rlen ;
+void async_add_timeout(struct wsgi_request *wsgi_req, int timeout) {
 
-	for(i=0;i<uwsgi.async_current_max;i++) {
-		wsgi_req = uwsgi.wsgi_requests[i];
-                if (wsgi_req->async_status == UWSGI_PAUSED) {
-			rlen = write(wsgi_req->poll.fd, data, len);
-			if (rlen < 0) {
-				uwsgi_error("write()");
+	if (timeout > 0 && wsgi_req->async_timeout == NULL) {
+        	wsgi_req->async_timeout = uwsgi_add_rb_timer(uwsgi.rb_async_timeouts, time(NULL)+timeout, wsgi_req);
+        }
+
+}
+
+void async_add_fd_write(struct wsgi_request *wsgi_req, int fd, int timeout) {
+
+        struct uwsgi_async_fd *last_uad = NULL, *uad = wsgi_req->waiting_fds;
+
+	if (fd < 0) return ;
+
+        // find first slot
+        while(uad) {
+                last_uad = uad;
+                uad = uad->next;
+        }
+
+        uad = uwsgi_malloc(sizeof(struct uwsgi_async_fd));
+        uad->fd = fd;
+	uad->event = event_queue_write();
+        uad->prev = last_uad;
+        uad->next = NULL;
+
+        if (last_uad) {
+                last_uad->next = uad;
+        }
+        else {
+                wsgi_req->waiting_fds = uad;
+        }
+
+	if (timeout > 0) {
+		async_add_timeout(wsgi_req, timeout);
+	}
+
+	uwsgi.async_waiting_fd_table[fd] = wsgi_req;
+        event_queue_add_fd_write(uwsgi.async_queue, fd);
+
+}
+
+void async_schedule_to_req(void) {
+	uwsgi.wsgi_req->async_status = uwsgi.p[uwsgi.wsgi_req->uh.modifier1]->request(uwsgi.wsgi_req);
+}
+
+void *async_loop(void *arg1) {
+
+	struct uwsgi_async_fd *tmp_uaf;
+	int interesting_fd, i;
+	struct uwsgi_rb_timer *min_timeout;
+	int timeout;
+	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.async_runqueue = NULL;
+	uwsgi.async_runqueue_cnt = 0;
+
+	// set a default request manager
+        if (!uwsgi.schedule_to_req) uwsgi.schedule_to_req = async_schedule_to_req;
+
+	while (uwsgi.workers[uwsgi.mywid].manage_next_request) {
+
+		if (uwsgi.async_runqueue_cnt) {
+			timeout = 0;
+		}
+		else {
+			min_timeout = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts);
+			if (uwsgi.async_runqueue_cnt) {
+                        	timeout = 0;
+			}
+                	if (min_timeout) {
+                        	timeout = min_timeout->key - time(NULL);
+                        	if (timeout <= 0) {
+                                	async_expire_timeouts();
+                                	timeout = 0;
+                        	}
 			}
 			else {
-				wsgi_req->response_size += rlen ;
+				timeout = -1;
+			}
+                }
+
+		uwsgi.async_nevents = event_queue_wait_multi(uwsgi.async_queue, timeout, events, 64);
+
+		// timeout ???
+		if (uwsgi.async_nevents == 0) {
+                	async_expire_timeouts();
+		}
+
+
+		for(i=0;i<uwsgi.async_nevents;i++) {
+			// manage events
+			interesting_fd = event_queue_interesting_fd(events, i);
+
+			is_a_new_connection = 0;
+
+			// new request coming in ?
+
+			uwsgi_sock = uwsgi.sockets;
+			while(uwsgi_sock) {
+
+				if (interesting_fd == uwsgi_sock->fd) {
+
+					is_a_new_connection = 1;	
+
+					uwsgi.wsgi_req = find_first_available_wsgi_req();
+					if (uwsgi.wsgi_req == NULL) {
+						now = time(NULL);
+						if (now > last_now) {
+							uwsgi_log("async queue is full !!!\n");
+							last_now = now;
+						}
+						break;;
+					}
+
+					wsgi_req_setup(uwsgi.wsgi_req, uwsgi.wsgi_req->async_id, uwsgi_sock );
+					if (wsgi_req_simple_accept(uwsgi.wsgi_req, interesting_fd)) {
+#ifdef UWSGI_EVENT_USE_PORT
+                                		event_queue_add_fd_read(uwsgi.async_queue, interesting_fd);
+#endif
+						uwsgi.async_queue_unused_ptr++;
+						uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req;
+						break;
+					}
+#ifdef UWSGI_EVENT_USE_PORT
+                                	event_queue_add_fd_read(uwsgi.async_queue, interesting_fd);
+#endif
+
+// on linux we do not need to reset the socket to blocking state
+#ifndef __linux__
+					if (uwsgi.numproc > 1) {
+	                                	/* re-set blocking socket */
+	                                	if (fcntl(uwsgi.wsgi_req->poll.fd, F_SETFL, uwsgi_sock->arg) < 0) {
+	                                        	uwsgi_error("fcntl()");
+							uwsgi.async_queue_unused_ptr++;
+							uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req;
+	                                		break;
+						}
+					}
+#endif
+
+					if (wsgi_req_async_recv(uwsgi.wsgi_req)) {
+						uwsgi.async_queue_unused_ptr++;
+						uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req;
+						break;
+					}
+
+					if (uwsgi.wsgi_req->do_not_add_to_async_queue) {
+						runqueue_push(uwsgi.wsgi_req);
+					}
+
+					break;
+				}
+
+				uwsgi_sock = uwsgi_sock->next;
+			}
+
+			if (!is_a_new_connection) {
+				// proto event
+				uwsgi.wsgi_req = find_wsgi_req_proto_by_fd(interesting_fd);
+				if (uwsgi.wsgi_req) {
+					proto_parser_status = uwsgi.wsgi_req->socket->proto(uwsgi.wsgi_req);
+					// reset timeout
+					rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+					free(uwsgi.wsgi_req->async_timeout);
+					uwsgi.wsgi_req->async_timeout = NULL;
+					// 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);
+						continue;
+					}
+					else if (proto_parser_status == -1) {
+						uwsgi_log("error parsing request\n");
+						uwsgi.async_proto_fd_table[interesting_fd] = NULL;
+						close(interesting_fd);
+						continue;
+					}
+					// re-add timer
+					async_add_timeout(uwsgi.wsgi_req, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+					continue;
+				}
+
+				// app event
+				uwsgi.wsgi_req = find_wsgi_req_by_fd(interesting_fd);
+				// unknown fd, remove it (for safety)
+				if (uwsgi.wsgi_req == NULL) {
+					close(interesting_fd);
+					continue;
+				}
+
+				// remove all the fd monitors and timeout
+				while(uwsgi.wsgi_req->waiting_fds) {
+#ifndef UWSGI_EVENT_USE_PORT
+                                        event_queue_del_fd(uwsgi.async_queue, uwsgi.wsgi_req->waiting_fds->fd, uwsgi.wsgi_req->waiting_fds->event);
+#endif
+                                        tmp_uaf = uwsgi.wsgi_req->waiting_fds;
+                                        uwsgi.async_waiting_fd_table[tmp_uaf->fd] = NULL;
+                                        uwsgi.wsgi_req->waiting_fds = tmp_uaf->next;
+                                        free(tmp_uaf);
+                                }
+				uwsgi.wsgi_req->waiting_fds = NULL;
+                                if (uwsgi.wsgi_req->async_timeout) {
+                                        rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+                                        free(uwsgi.wsgi_req->async_timeout);
+                                        uwsgi.wsgi_req->async_timeout = NULL;
+                                }	
+
+				uwsgi.wsgi_req->async_ready_fd = 1;
+				uwsgi.wsgi_req->async_last_ready_fd = interesting_fd;
+
+				// put the request in the runqueue again
+				runqueue_push(uwsgi.wsgi_req);
 			}
 		}
-	}
-}
 
-void async_unpause_all() {
-	
-	struct wsgi_request *wsgi_req ;
-	int i;
+		// event queue managed, give cpu to runqueue
+		if (!current_request)
+			current_request = uwsgi.async_runqueue;
+
+		if (uwsgi.async_runqueue_cnt) {
+
+			uwsgi.wsgi_req = current_request->wsgi_req;
+
+			uwsgi.schedule_to_req();
+			uwsgi.wsgi_req->switches++;
+
+			next_async_request = current_request->next;
+			// request ended ?
+			if (uwsgi.wsgi_req->async_status <= UWSGI_OK) {
+				// remove all the monitored fds and timeout
+				while(uwsgi.wsgi_req->waiting_fds) {
+#ifndef UWSGI_EVENT_USE_PORT
+					event_queue_del_fd(uwsgi.async_queue, uwsgi.wsgi_req->waiting_fds->fd, uwsgi.wsgi_req->waiting_fds->event);
+#endif
+					tmp_uaf = uwsgi.wsgi_req->waiting_fds;
+					uwsgi.async_waiting_fd_table[tmp_uaf->fd] = NULL;
+					uwsgi.wsgi_req->waiting_fds = tmp_uaf->next;
+					free(tmp_uaf);
+				}
+				uwsgi.wsgi_req->waiting_fds = NULL;
+				if (uwsgi.wsgi_req->async_timeout) {
+					rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+                        		free(uwsgi.wsgi_req->async_timeout);
+                        		uwsgi.wsgi_req->async_timeout = NULL;
+				}
+
+				// remove from the list
+				runqueue_remove(current_request);
+
+				uwsgi_close_request(uwsgi.wsgi_req);
+
+				// push wsgi_request in the unused stack
+				uwsgi.async_queue_unused_ptr++;
+				uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req;
+
+			}
+			else if (uwsgi.wsgi_req->waiting_fds || uwsgi.wsgi_req->async_timeout) {
+				// remove this request from suspended list	
+				runqueue_remove(current_request);
+			}
+
+			current_request = next_async_request;
 
-	for(i=0;i<uwsgi.async_current_max;i++) {
-		wsgi_req = uwsgi.wsgi_requests[i];
-                if (wsgi_req->async_status == UWSGI_PAUSED) {
-			wsgi_req->async_status = UWSGI_AGAIN;
 		}
-	}
-}
 
-struct wsgi_request * async_loop() {
 
-	struct wsgi_request *wsgi_req ;
-	int i ;
-	int ret;
-
-	uwsgi.async_running = -1 ;
-
-	for(i=0;i<uwsgi.async_current_max;i++) {
-		wsgi_req = uwsgi.wsgi_requests[i];
-        	if (wsgi_req->async_status == UWSGI_AGAIN) {
-			if (wsgi_req->sigwait) {
-				uwsgi_log("waiting for signal\n");
-				continue;
-			}
-                	else if (wsgi_req->async_waiting_fd != -1 && !wsgi_req->async_waiting_fd_monitored) {
-				// add fd to monitoring
-				ret = -1;
-				if (wsgi_req->async_waiting_fd_type == ASYNC_IN) {
-					ret = event_queue_add_fd_read(uwsgi.async_queue, wsgi_req->async_waiting_fd);
-				}
-				else if (wsgi_req->async_waiting_fd_type == ASYNC_OUT) {
-					ret = event_queue_add_fd_write(uwsgi.async_queue, wsgi_req->async_waiting_fd);
-				}
-
-				if (ret < 0) {
-					// error adding fd to the async queue, better to close it...
-					close(wsgi_req->async_waiting_fd);
-					wsgi_req->async_status = UWSGI_OK ;
-					return wsgi_req;
-				}
-				uwsgi.async_waiting_fd_table[wsgi_req->async_waiting_fd] = wsgi_req->async_id;
-				wsgi_req->async_waiting_fd_monitored = 1;
-				wsgi_req->async_status = UWSGI_AGAIN;
-			}
-			else if (wsgi_req->async_waiting_fd == -1 && wsgi_req->async_timeout <= 0) {
-                		uwsgi.async_running = 0 ;
-				// st global wsgi_req
-				uwsgi.wsgi_req = wsgi_req ;
-
-				uwsgi_log("!!! getting new part\n");
-				wsgi_req->async_status = uwsgi.p[wsgi_req->uh.modifier1]->request(wsgi_req);;
-
-				wsgi_req->switches++;
-
-				if (wsgi_req->async_status < UWSGI_AGAIN) {
-					return wsgi_req;
-				}
-			}
-		}
 	}
 
 	return NULL;

bootstrap.py

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

bootstrap2.py

@@ -0,0 +1,4 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("pygments_zip"))

bootstrap3.py

@@ -0,0 +1,5 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("django_zip:djenv/lib/python2.6/site-packages"))
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("djapp_zip"))

build/README

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

buildconf/default.ini

@@ -2,6 +2,9 @@
 xml = true
 ini = true
 yaml = true
+json = auto
+sqlite3 = auto
+zeromq = auto
 snmp = true
 sctp = false
 spooler = true
@@ -13,22 +16,28 @@ sendfile = true
 minterpreters = true
 async = true
 evdis = false
-ldap = false
+ldap = auto
 pcre = auto
-stackless = false
 debug = false
 unbit = false
 xml_implementation = libxml2
+yaml_implementation = auto
+malloc_implementation = libc
 plugins =
 bin_name = uwsgi
+append_version =
 plugin_dir = .
-embedded_plugins = python, ping, nagios, rpc, fastrouter, http
+embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, ugreen
 
 locking = auto
 event = auto
 timer = auto
 filemonitor = auto
 
+embed_files =
+
+embed_config =
+
 [python]
 paste = true
 web3 = true

buildconf/django.ini

@@ -0,0 +1,3 @@
+[uwsgi]
+inherit = default
+embed_files = bootstrap3.py,django.zip,djapp.zip

buildconf/embedded.ini

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

buildconf/modular.ini

@@ -1,33 +1,5 @@
 [uwsgi]
-xml = true
-ini = true
-snmp = true
-sctp = false
-erlang = false
-spooler = false
-embedded = false
-udp = true
-multicast = false
-threading = true
-sendfile = true
-nagios = true
-proxy = true
-minterpreters = true
-async = true
-ugreen = false
-http = true
-evdis = false
-ldap = true
-routing = false
-stackless = false
-debug = false
-unbit = false
-xml_implementation = libxml2
-plugins = python, ping, rack
-bin_name = uwsgi
-plugin_dir = .
-embedded_plugins =
-
-[python]
-paste = true
-web3 = true
+inherit = default
+plugins = python, ping, rack, psgi, cache, http, fastrouter
+plugin_dir = plugins
+embedded_plugins = null

buildconf/package.ini

@@ -0,0 +1,4 @@
+[uwsgi]
+inherit = default
+plugin_dir = /usr/lib/uwsgi
+embedded_plugins = null

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,4 +1,6 @@
 [uwsgi]
 inherit = unbit
+json = false
+embedded_plugins = python
 bin_name = ../bin/uwsgi
 plugin_dir = ../bin/uwsgi_plugins

cache.c

@@ -2,6 +2,98 @@
 
 extern struct uwsgi_server uwsgi;
 
+void uwsgi_init_cache() {
+	int i;
+
+	if (!uwsgi.cache_blocksize)
+                        uwsgi.cache_blocksize = UMAX16;
+
+                if (uwsgi.cache_blocksize % uwsgi.page_size != 0) {
+                        uwsgi_log("invalid cache blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.cache_blocksize, uwsgi.page_size);
+                        exit(1);
+                }
+
+                uwsgi.cache_hashtable = (uint64_t *) mmap(NULL, sizeof(uint64_t) * UMAX16, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                if (!uwsgi.cache_hashtable) {
+                        uwsgi_error("mmap()");
+                        exit(1);
+                }
+
+                memset(uwsgi.cache_hashtable, 0, sizeof(uint64_t) * UMAX16);
+
+                uwsgi.cache_unused_stack = (uint64_t *) mmap(NULL, sizeof(uint64_t) * uwsgi.cache_max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                if (!uwsgi.cache_unused_stack) {
+                        uwsgi_error("mmap()");
+                        exit(1);
+                }
+
+                memset(uwsgi.cache_unused_stack, 0, sizeof(uint64_t) * uwsgi.cache_max_items);
+
+                // the first cache item is always zero
+                uwsgi.shared->cache_first_available_item = 1;
+                uwsgi.shared->cache_unused_stack_ptr = 0;
+
+                //uwsgi.cache_items = (struct uwsgi_cache_item *) mmap(NULL, sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                if (uwsgi.cache_store) {
+                        uwsgi.cache_filesize = (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items) + (uwsgi.cache_blocksize * uwsgi.cache_max_items);
+                        int cache_fd;
+                        struct stat cst;
+
+                        if (stat(uwsgi.cache_store, &cst)) {
+                                uwsgi_log("creating a new cache store file: %s\n", uwsgi.cache_store);
+                                cache_fd = open(uwsgi.cache_store, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+                                if (cache_fd >= 0) {
+                                        // fill the caching store
+                                        if (ftruncate(cache_fd, uwsgi.cache_filesize)) {
+                                                uwsgi_log("ftruncate()");
+                                                exit(1);
+                                        }
+                                }
+                        }
+                        else {
+                                if ((size_t) cst.st_size != uwsgi.cache_filesize || !S_ISREG(cst.st_mode)) {
+                                        uwsgi_log("invalid cache store file. Please remove it or fix cache blocksize/items to match its size\n");
+                                        exit(1);
+                                }
+                                cache_fd = open(uwsgi.cache_store, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+                                uwsgi_log("recovered cache from backing store file: %s\n", uwsgi.cache_store);
+                        }
+
+                        if (cache_fd < 0) {
+                                uwsgi_error_open(uwsgi.cache_store);
+                                exit(1);
+                        }
+                        uwsgi.cache_items = (struct uwsgi_cache_item *) mmap(NULL, uwsgi.cache_filesize, PROT_READ | PROT_WRITE, MAP_SHARED, cache_fd, 0);
+                        uwsgi_cache_fix();
+
+                }
+                else {
+                        uwsgi.cache_items = (struct uwsgi_cache_item *) mmap(NULL, (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items) + (uwsgi.cache_blocksize * uwsgi.cache_max_items), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                        for (i = 0; i < (int) uwsgi.cache_max_items; i++) {
+                                memset(&uwsgi.cache_items[i], 0, sizeof(struct uwsgi_cache_item));
+                        }
+                }
+                if (!uwsgi.cache_items) {
+                        uwsgi_error("mmap()");
+                        exit(1);
+                }
+
+                /*
+                   uwsgi.cache = mmap(NULL, uwsgi.cache_blocksize * uwsgi.cache_max_items, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                   if (!uwsgi.cache) {
+                   uwsgi_error("mmap()");
+                   exit(1);
+                   }
+                 */
+
+                uwsgi.cache = ((void *) uwsgi.cache_items) + (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items);
+
+                uwsgi.cache_lock = uwsgi_mmap_shared_rwlock();
+                uwsgi_rwlock_init(uwsgi.cache_lock);
+
+                uwsgi_log("*** Cache subsystem initialized: %dMB preallocated ***\n", ((sizeof(uint64_t) * UMAX16) + (sizeof(uint64_t) * uwsgi.cache_max_items) + (uwsgi.cache_blocksize * uwsgi.cache_max_items) + (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items)) / (1024 * 1024));
+}
+
 struct uwsgi_subscriber_name *uwsgi_get_subscriber(struct uwsgi_dict *udict, char *key, uint16_t keylen) {
 
 	uint64_t ovl;
@@ -39,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;
@@ -47,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;
 			}
@@ -65,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++;
 			}
@@ -76,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));
 	}
 
 }
@@ -330,6 +426,27 @@ int uwsgi_cache_del(char *key, uint16_t keylen) {
 	return ret;
 }
 
+void uwsgi_cache_fix() {
+
+	uint64_t i;
+
+	for(i=0;i< uwsgi.cache_max_items;i++) {
+		// valid record ?
+		if (uwsgi.cache_items[i].keysize) {
+			if (!uwsgi.cache_items[i].prev) {
+				// put value in hash_table
+				uwsgi.cache_hashtable[ uwsgi.cache_items[i].djbhash % 0xffff] = i;
+			}
+		}
+		else {
+			// put this record in unused stack
+			uwsgi.shared->cache_first_available_item = i;
+			uwsgi.shared->cache_unused_stack_ptr++;
+			uwsgi.cache_unused_stack[uwsgi.shared->cache_unused_stack_ptr] = i;
+		}
+	}
+}
+
 int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint64_t expires, uint16_t flags) {
 
 	uint64_t index = 0, last_index = 0 ;
@@ -466,101 +583,124 @@ end:
 
 }
 
+/* THIS PART IS HEAVILY OPTIMIZED: PERFORMANCE NOT ELEGANCE !!! */
 
-void cache_command(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
+void *cache_thread_loop(void *fd_ptr) {
 
-	struct wsgi_request *wsgi_req = (struct wsgi_request *) data;
-	uint64_t tmp_vallen = 0;
+	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;
 
-	if (vallen > 0) {
-		if (!uwsgi_strncmp(key, keylen, "key", 3)) {
-			val = uwsgi_cache_get(val, vallen, &tmp_vallen);
-                        if (val && tmp_vallen > 0) {
-                        	wsgi_req->response_size = write(wsgi_req->poll.fd, val, vallen);
-                        }
+	ctl_poll.events = POLLIN;
 
-		}		
-		else if (!uwsgi_strncmp(key, keylen, "get", 3)) {
-			val = uwsgi_cache_get(val, vallen, &tmp_vallen);
-			if (val && vallen > 0) {
-                        	wsgi_req->response_size = write(wsgi_req->poll.fd, val, tmp_vallen);
+	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;
 			}
-			else {
-				wsgi_req->response_size = write(wsgi_req->poll.fd, "HTTP/1.0 404 Not Found\r\n\r\n<h1>Not Found</h1>", 44);
+			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()");
 			}
 		}
-	}
-}
 
-int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
-
-	uint64_t vallen = 0;
-	char *value;
-	char *argv[3];
-	uint8_t argc = 0;
-
-	switch(wsgi_req->uh.modifier2) {
-		case 0:
-			// get
-			if (wsgi_req->uh.pktsize > 0) {
-				value = uwsgi_cache_get(wsgi_req->buffer, wsgi_req->uh.pktsize, &vallen);
-				if (value && vallen > 0) {
-					wsgi_req->uh.pktsize = vallen;
-					wsgi_req->response_size = write(wsgi_req->poll.fd, &wsgi_req->uh, 4);
-					wsgi_req->response_size += write(wsgi_req->poll.fd, value, vallen);
-				}
-			}
-			break;		
-		case 1:
-			// set
-			if (wsgi_req->uh.pktsize > 0) {
-				argc = 3;
-				if (!uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh.pktsize, argv, &argc)) {
-					if (argc > 1) {
-						uwsgi_cache_set(argv[0], strlen(argv[0]), argv[1], strlen(argv[1]), 0, 0);
-					}
-				}
-			}
-			break;
-		case 2:
-			// del
-			if (wsgi_req->uh.pktsize > 0) {
-				uwsgi_cache_del(wsgi_req->buffer, wsgi_req->uh.pktsize);
-			}
-			break;
-		case 4:
-			// dict
-			if (wsgi_req->uh.pktsize > 0) {
-				uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh.pktsize, cache_command, (void *) wsgi_req);
-			}
-			break;
-		case 5:
-			// get (uwsgi + stream)
-			if (wsgi_req->uh.pktsize > 0) {
-				value = uwsgi_cache_get(wsgi_req->buffer, wsgi_req->uh.pktsize, &vallen);
-				if (value && vallen > 0) {
-					wsgi_req->uh.pktsize = 0;
-					wsgi_req->uh.modifier2 = 1;
-					wsgi_req->response_size = write(wsgi_req->poll.fd, &wsgi_req->uh, 4);
-					wsgi_req->response_size += write(wsgi_req->poll.fd, value, vallen);
-				}
-				else {
-					wsgi_req->uh.pktsize = 0;
-					wsgi_req->uh.modifier2 = 0;
-					wsgi_req->response_size = write(wsgi_req->poll.fd, &wsgi_req->uh, 4);
-				}
-			}
-			break;		
+clear:
+		close(ctl_poll.fd);
 	}
 
-	return 0;
+	return NULL;
 }
 
-struct uwsgi_plugin uwsgi_cache_plugin = {
+int uwsgi_cache_server(char *socket, int threads) {
 
-        .name = "cache",
-        .modifier1 = 111, 
-        .request = uwsgi_cache_request,
+	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;
+}
 

contrib/graphite_uwsgi.py

@@ -0,0 +1,33 @@
+# uwsgi --master --chdir /opt/graphite/webapp/graphite --module graphite_uwsgi ...
+#
+#
+# this module will update a carbon server (used by the graphite tool: http://graphite.wikidot.com/)
+# with requests count made by a Django app (and can track graphite itself as it is a Django app ;)
+#
+#
+
+import os
+import uwsgi
+import time
+from django.core.handlers.wsgi import WSGIHandler
+
+os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
+
+CARBON_SERVER = "127.0.0.1:2003"
+
+def update_carbon(signum):
+    # connect to the carbon server
+    carbon_fd = uwsgi.connect(CARBON_SERVER)
+    # send data to the carbon server
+    uwsgi.send(carbon_fd, "uwsgi.%s.requests %d %d\n" % (uwsgi.hostname, uwsgi.total_requests(), int(time.time())))
+    # close the connection with the carbon server
+    uwsgi.close(carbon_fd)
+
+# register a new uwsgi signal (signum: 17)
+uwsgi.register_signal(17, '', update_carbon)
+
+# attach a timer of 10 seconds to signal 17
+uwsgi.add_timer(17, 10)
+
+# the Django app
+application = WSGIHandler()

contrib/runuwsgi.py

@@ -0,0 +1,66 @@
+import django
+from django.core.management.base import BaseCommand
+from django.conf import settings
+import os
+import sys
+
+class Command(BaseCommand):
+    help = "Runs this project as a uWSGI application. Requires the uwsgi binary in system path."
+
+    http_port = '8000'
+    socket_addr = None
+
+    def handle(self, *args, **options):
+        for arg in args:
+            k,v = arg.split('=')
+            if k == 'http':
+                if self.http_port:
+                   self.http_port = v
+            elif k == 'socket':
+                self.http_port = None
+                self.socket_addr = v
+
+        # load http and python plugin: first the specific version, otherwise try with the generic one
+        if self.http_port:
+            os.environ['UWSGI_PLUGINS'] = 'http,python%d%d:python' % (sys.version_info[0], sys.version_info[1])
+        else:
+            os.environ['UWSGI_PLUGINS'] = 'python%d%d:python' % (sys.version_info[0], sys.version_info[1])
+
+        # load the Django WSGI handler
+        os.environ['UWSGI_MODULE'] = 'django.core.handlers.wsgi:WSGIHandler()'
+        # DJANGO settings
+        if options['settings']:
+            os.environ['DJANGO_SETTINGS_MODULE'] = options['settings']
+        else:
+            os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
+
+        # bind the http server to the default port
+        if self.http_port:
+            os.environ['UWSGI_HTTP'] = ':%s' % self.http_port
+        elif self.socket_addr:
+            os.environ['UWSGI_SOCKET'] = self.socket_addr
+
+	# map admin static files
+	os.environ['UWSGI_STATIC_MAP'] = '%s=%s' % (settings.ADMIN_MEDIA_PREFIX, os.path.join(django.__path__[0], 'contrib', 'admin', 'media'))
+        # remove sockets/pidfile at exit
+        os.environ['UWSGI_VACUUM'] = '1'
+        # retrieve/set the PythonHome
+        os.environ['UWSGI_PYHOME'] = sys.prefix
+        # increase buffer size a bit
+        os.environ['UWSGI_BUFFER_SIZE'] = '8192'
+        # add threads for concurrency
+        os.environ['UWSGI_THREADS'] = '8'
+        # enable the master process
+        os.environ['UWSGI_MASTER'] = '1'
+        # use uWSGI python module aliasing to fix the PYTHONPATH
+        os.environ['UWSGI_PYMODULE_ALIAS'] = '%s=./' % os.path.basename(os.getcwd())
+        # exec the uwsgi binary
+        os.execvp('uwsgi', ('uwsgi',))
+
+    def usage(self, subcomand):
+        return r"""
+run this project on the uWSGI server
+
+  http=PORT		run the embedded http server on port PORT
+  socket=ADDR		bind the uwsgi server on address ADDR (this will disable the http server)
+        """

contrib/xinetd_uwsgi

@@ -0,0 +1,14 @@
+service uwsgi
+{
+        disable         = no
+        id              = uwsgi-000
+        type            = UNLISTED
+        socket_type     = stream
+        server          = /root/uwsgi/uwsgi
+        server_args     = --chdir /root/uwsgi/ --module welcome --logto /tmp/uwsgi.log
+        port            = 3031
+        bind            = 127.0.0.1
+        user            = root
+        wait            = yes
+}
+

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

@@ -5,29 +5,93 @@
 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;
+        struct uwsgi_instance *ui_prev;
+        struct uwsgi_instance *ui_next;
 
-	char name[0xff];
-	pid_t pid ;
+        char name[0xff];
+        pid_t pid;
 
-	int status;
-	time_t born;
-	time_t last_mod;
+        int status;
+        time_t born;
+        time_t last_mod;
+        time_t last_loyal;
 
-	uint64_t respawns;
+        uint64_t respawns;
+        int use_config;
 
-	int pipe[2];
+        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);
+}
+
+
+void emperor_stats() {
+
+	struct uwsgi_instance *c_ui = ui->ui_next;
+
+        while (c_ui) {
+
+		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);
+
+                c_ui = c_ui->ui_next;
+        }
+
+}
+
+struct uwsgi_instance *emperor_get_by_fd(int fd) {
+
+        struct uwsgi_instance *c_ui = ui;
+
+        while (c_ui->ui_next) {
+                c_ui = c_ui->ui_next;
+
+                if (c_ui->pipe[0] == fd) {
+                        return c_ui;
+                }
+        }
+        return NULL;
+}
+
+
 struct uwsgi_instance *emperor_get(char *name) {
-	
+
 	struct uwsgi_instance *c_ui = ui;
-	
-	while(c_ui->ui_next) {
+
+	while (c_ui->ui_next) {
 		c_ui = c_ui->ui_next;
 
 		if (!strcmp(c_ui->name, name)) {
@@ -50,8 +114,25 @@ void emperor_del(struct uwsgi_instance *c_ui) {
 	// this will destroy the whole uWSGI instance (and workers)
 	close(c_ui->pipe[0]);
 
+	if (c_ui->use_config) {
+		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);
 
 }
@@ -71,44 +152,84 @@ void emperor_stop(struct uwsgi_instance *c_ui) {
 void emperor_respawn(struct uwsgi_instance *c_ui, time_t mod) {
 
 	// reload the uWSGI instance
-	if (write(c_ui->pipe[0], "\1", 1) != 1) {
-                uwsgi_error("write()");
-        }
+	if (c_ui->use_config) {
+		if (write(c_ui->pipe[0], "\0", 1) != 1) {
+			uwsgi_error("write()");
+		}
+	}
+	else {
+		if (write(c_ui->pipe[0], "\1", 1) != 1) {
+			uwsgi_error("write()");
+		}
+	}
 
-        c_ui->respawns++;
+	c_ui->respawns++;
 	c_ui->last_mod = mod;
 
-        uwsgi_log("reload the uwsgi instance %s\n", c_ui->name);
+	uwsgi_log("reload the uwsgi instance %s\n", c_ui->name);
 }
 
-void emperor_add(char *name, time_t born) {
+void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 
 	struct uwsgi_instance *c_ui = ui;
 	struct uwsgi_instance *n_ui = NULL;
-	pid_t pid ;
-	char *argv[4];
-	char *uef ;
+	pid_t pid;
+	char **argv;
+	char *uef;
 	char **uenvs;
+	int counter;
+	char *colon = NULL;
+	int i;
 
-        while(c_ui->ui_next) {
-                c_ui = c_ui->ui_next;
-        }
+	sleep(1);
+
+	while (c_ui->ui_next) {
+		c_ui = c_ui->ui_next;
+	}
 
 	n_ui = uwsgi_malloc(sizeof(struct uwsgi_instance));
 	memset(n_ui, 0, sizeof(struct uwsgi_instance));
 
+	if (config) {
+		n_ui->use_config = 1;	
+		n_ui->config = config;
+		n_ui->config_len = config_size;
+	}
+
 	c_ui->ui_next = n_ui;
+#ifdef UWSGI_DEBUG
 	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;
+	// start without loyalty
+	n_ui->last_loyal = born;
+	n_ui->loyal = 0;
 
 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, n_ui->pipe)) {
 		uwsgi_error("socketpair()");
 		goto clear;
 	}
 
+	event_queue_add_fd_read(emperor_queue, n_ui->pipe[0]);
+
+	if (n_ui->use_config) {
+		if (socketpair(AF_UNIX, SOCK_STREAM, 0, n_ui->pipe_config)) {
+			uwsgi_error("socketpair()");
+			goto clear;
+		}
+	}
+
+	// TODO pre-start hook
+
 	// a new uWSGI instance will start 
 	pid = fork();
 	if (pid < 0) {
@@ -118,9 +239,23 @@ void emperor_add(char *name, time_t born) {
 		n_ui->pid = pid;
 		// close the right side of the pipe
 		close(n_ui->pipe[1]);
+		if (n_ui->use_config) {
+			close(n_ui->pipe_config[1]);
+		}
+
+		if (n_ui->use_config) {
+			if (write(n_ui->pipe_config[0], n_ui->config, n_ui->config_len) <= 0) {
+				uwsgi_error("write()");
+			}
+			close(n_ui->pipe_config[0]);
+		}
 		return;
 	}
 	else {
+
+		unsetenv("UWSGI_RELOADS");
+		unsetenv("NOTIFY_SOCKET");
+
 		uef = uwsgi_num2str(n_ui->pipe[1]);
 		if (setenv("UWSGI_EMPEROR_FD", uef, 1)) {
 			uwsgi_error("setenv()");
@@ -128,10 +263,19 @@ void emperor_add(char *name, time_t born) {
 		}
 		free(uef);
 
+		if (n_ui->use_config) {
+			uef = uwsgi_num2str(n_ui->pipe_config[1]);
+			if (setenv("UWSGI_EMPEROR_FD_CONFIG", uef, 1)) {
+				uwsgi_error("setenv()");
+				exit(1);
+			}
+			free(uef);
+		}
+
 		uenvs = environ;
-		while(*uenvs) {
+		while (*uenvs) {
 			if (!strncmp(*uenvs, "UWSGI_VASSAL_", 13)) {
-				char *ne = uwsgi_concat2("UWSGI_", *uenvs+13);
+				char *ne = uwsgi_concat2("UWSGI_", *uenvs + 13);
 				char *oe = uwsgi_concat2n(*uenvs, strchr(*uenvs, '=') - *uenvs, "", 0);
 				if (unsetenv(oe)) {
 					uwsgi_error("unsetenv()");
@@ -153,24 +297,78 @@ void emperor_add(char *name, time_t born) {
 		// close the left side of the pipe
 		close(n_ui->pipe[0]);
 
+		if (n_ui->use_config) {
+			close(n_ui->pipe_config[0]);
+		}
 
+		counter = 4;
+		struct uwsgi_config_template *uct = uwsgi.vassals_templates;
+                while(uct) {
+			counter+=2;
+			uct = uct->next;
+		}
+
+		argv = uwsgi_malloc(sizeof(char *) * counter);
 		// set args
 		argv[0] = uwsgi.binary_path;
-		if (!strcmp(name+(strlen(name)-4), ".xml")) argv[1] = "--xml";
-		if (!strcmp(name+(strlen(name)-4), ".ini")) argv[1] = "--ini";
-		if (!strcmp(name+(strlen(name)-4), ".yml")) argv[1] = "--yaml";
-		if (!strcmp(name+(strlen(name)-5), ".yaml")) argv[1] = "--yaml";
+
+		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"))
+			argv[1] = "--ini";
+		if (!strcmp(name + (strlen(name) - 4), ".yml"))
+			argv[1] = "--yaml";
+		if (!strcmp(name + (strlen(name) - 5), ".yaml"))
+			argv[1] = "--yaml";
+		if (!strcmp(name + (strlen(name) - 3), ".js"))
+			argv[1] = "--json";
+
+		if (colon) {
+			colon[0] = ':';
+		}
 		argv[2] = name;
-		argv[3] = NULL;
+		counter = 3;
+		uct = uwsgi.vassals_templates;
+        	while(uct) {
+			argv[counter] = "--inherit";
+			argv[counter+1] = uct->filename;
+			counter+=2;
+			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()");
 		}
+		uwsgi_log("is the uwsgi binary in your system PATH ?\n");
 		// never here
-		exit(1);
+		exit(UWSGI_EXILE_CODE);
 	}
 
-clear:
+      clear:
 
 	free(n_ui);
 	c_ui->ui_next = NULL;
@@ -193,56 +391,232 @@ void emperor_loop() {
 	glob_t g;
 	int i;
 	struct dirent *de;
+	char *amqp_port;
+	int amqp_fd = -1;
+	char *amqp_routing_key;
+
+	void *events;
+	int nevents;
+	int interesting_fd;
+	char notification_message[64];
+
+	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));
 
-	uwsgi_log("*** starting uWSGI Emperor ***\n");
 
-	if (!glob(uwsgi.emperor_dir, GLOB_MARK, 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)) {
-				uwsgi_error("chdir()");
-				exit(1);
-			}
-		}
+	emperor_queue = event_queue_init();
+
+        events = event_queue_alloc(64);
+
+	if (uwsgi.has_emperor) {
+		uwsgi_log("*** starting uWSGI sub-Emperor ***\n");
 	}
 	else {
-		uwsgi_error("glob()");
-		exit(1);
+		uwsgi_log("*** starting uWSGI Emperor ***\n");
+	}
+
+	amqp_port = strchr(uwsgi.emperor_dir, ':');
+
+	if (amqp_port) {
+		if (uwsgi.emperor_amqp_vhost == NULL) uwsgi.emperor_amqp_vhost = "/";
+		if (uwsgi.emperor_amqp_username == NULL) uwsgi.emperor_amqp_username = "guest";
+		if (uwsgi.emperor_amqp_password == NULL) uwsgi.emperor_amqp_password = "guest";
+reconnect:
+		while(amqp_fd == -1) {	
+			uwsgi_log("connecting to AMQP server...\n");
+			amqp_fd = uwsgi_connect(uwsgi.emperor_dir, -1, 0);
+			if (amqp_fd < 0) {
+				sleep(1);
+			}
+		}
+
+		uwsgi_log("subscribing to queue...\n");
+		if (uwsgi_amqp_consume_queue(amqp_fd, uwsgi.emperor_amqp_vhost, uwsgi.emperor_amqp_username, uwsgi.emperor_amqp_password, "", "uwsgi.emperor", "fanout") < 0) {
+			close(amqp_fd);
+			amqp_fd = -1;
+			sleep(1);
+			goto reconnect;
+		}
+
+		event_queue_add_fd_read(emperor_queue, amqp_fd);
+	}
+	else {
+		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)) {
+					uwsgi_error("chdir()");
+					exit(1);
+				}
+			}
+		}
+		else {
+			uwsgi_error("glob()");
+			exit(1);
+		}
+		emperor_absolute_dir = realpath(".", NULL);
 	}
 
 	ui = &ui_base;
 
-	for(;;) {
+	int freq = 0 ;
+
+	for (;;) {
 
 
 		if (!i_am_alone) {
 			diedpid = waitpid(uwsgi.emperor_pid, &waitpid_status, WNOHANG);
-			if (diedpid < 0) {
-				uwsgi_error("waitpid()");
-			}
-			else if (diedpid > 0) {
+			if (diedpid < 0 || diedpid > 0) {
 				i_am_alone = 1;
 			}
 		}
 
+		nevents = event_queue_wait_multi(emperor_queue, freq, events, 64);
+		freq = 3;
+
+		for (i = 0; i<nevents;i++) {
+			interesting_fd = event_queue_interesting_fd(events, i);
+
+			if (amqp_fd > -1 && interesting_fd == amqp_fd ) {
+				uint64_t msgsize;
+				char *config = uwsgi_amqp_consume(amqp_fd, &msgsize, &amqp_routing_key);
+				
+				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;
+				}
+
+				if (amqp_routing_key) {
+					uwsgi_log("AMQP routing_key = %s\n", amqp_routing_key);
+					char *config_file = uwsgi_concat2("emperor://", amqp_routing_key);
+					free(amqp_routing_key);
+
+					ui_current = emperor_get(config_file);
+
+                                        if (ui_current) {
+						// ignore event if i am not loyal
+						if (!ui_current->loyal) continue;
+						free(ui_current->config);
+						ui_current->config = config;
+						ui_current->config_len = msgsize;
+						if (!msgsize) {
+							// SAFE
+							emperor_del(ui_current);
+						}
+						else {
+                                                	emperor_respawn(ui_current, time(NULL));
+						}
+                                        }
+                                        else {
+						if (msgsize > 0) {
+                                                	emperor_add(config_file, time(NULL), config, msgsize);
+						}
+                                        }
+
+					
+                                        free(config_file);
+				}
+				else {
+				if (msgsize) {
+					if (msgsize >= 0xff) { free(config); continue; }
+
+#ifdef UWSGI_DEBUG
+					uwsgi_log("%.*s\n", (int)msgsize, config);
+#endif
+					char *config_file = uwsgi_concat2n(config, msgsize, "", 0);
+					free(config);
+
+					if (strncmp(config_file, "http://", 7)) {
+						if (stat(config_file, &st)) {
+							free(config_file);
+							continue;
+						}
+
+						if (!S_ISREG(st.st_mode)) {
+							free(config_file);
+							continue;
+						}
+					}
+
+					ui_current = emperor_get(config_file);
+
+					if (ui_current) {
+						// ignore event if i am not loyal
+						if (!ui_current->loyal) continue;
+						emperor_respawn(ui_current, time(NULL));
+					}
+					else {
+						emperor_add(config_file, time(NULL), NULL, 0);
+					}
+
+					free(config_file);
+				}
+				}
+			}
+			else {
+				ui_current = emperor_get_by_fd(interesting_fd);
+				if (ui_current) {
+					char byte;
+					ssize_t rlen = read(interesting_fd, &byte, 1);
+					if (rlen <= 0) {
+						// SAFE
+						emperor_del(ui_current);
+					}
+					else {
+						if (byte == 17) {
+							ui_current->loyal = 1;
+							uwsgi_log("*** vassal %s is now loyal ***\n", ui_current->name);
+							
+							// 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);
+				}
+			}
+		}
+
+		if (amqp_fd == -1) {
 		if (simple_mode) {
 			DIR *dir = opendir(".");
-			while((de = readdir(dir)) != NULL) {
-				if (!strcmp(de->d_name+(strlen(de->d_name)-4), ".xml") ||
-					!strcmp(de->d_name+(strlen(de->d_name)-4), ".ini") ||
-					!strcmp(de->d_name+(strlen(de->d_name)-4), ".yml") ||
-					!strcmp(de->d_name+(strlen(de->d_name)-5), ".yaml")
+			while ((de = readdir(dir)) != NULL) {
+				if (!strcmp(de->d_name + (strlen(de->d_name) - 4), ".xml") ||
+					!strcmp(de->d_name + (strlen(de->d_name) - 4), ".ini") ||
+					!strcmp(de->d_name + (strlen(de->d_name) - 4), ".yml") ||
+					!strcmp(de->d_name + (strlen(de->d_name) - 5), ".yaml") ||
+					!strcmp(de->d_name + (strlen(de->d_name) - 3), ".js")
 					) {
 
-				
-					if (strlen(de->d_name) >= 0xff) continue;
 
-					if (stat(de->d_name, &st)) continue;
+					if (strlen(de->d_name) >= 0xff)
+						continue;
+
+					if (stat(de->d_name, &st))
+						continue;
+
+					if (!S_ISREG(st.st_mode))
+						continue;
 
-					if (!S_ISREG(st.st_mode)) continue;
-		
 					ui_current = emperor_get(de->d_name);
 
 					if (ui_current) {
@@ -252,97 +626,125 @@ void emperor_loop() {
 						}
 					}
 					else {
-						emperor_add(de->d_name, st.st_mtime);
+						emperor_add(de->d_name, st.st_mtime, NULL, 0);
 					}
 				}
 			}
 			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;
 			}
 
-			for(i=0;i<(int)g.gl_pathc;i++) {
-				if (!strcmp(g.gl_pathv[i]+(strlen(g.gl_pathv[i])-4), ".xml") ||
-                                        !strcmp(g.gl_pathv[i]+(strlen(g.gl_pathv[i])-4), ".ini") ||
-                                        !strcmp(g.gl_pathv[i]+(strlen(g.gl_pathv[i])-4), ".yml") ||
-                                        !strcmp(g.gl_pathv[i]+(strlen(g.gl_pathv[i])-5), ".yaml")
-                                        ) {
+			for (i = 0; i < (int) g.gl_pathc; i++) {
+				if (!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 4), ".xml") ||
+					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 4), ".ini") ||
+					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 4), ".yml") ||
+					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 3), ".js") ||
+					!strcmp(g.gl_pathv[i] + (strlen(g.gl_pathv[i]) - 5), ".yaml")
+					) {
 
 
-                                        if (strlen(g.gl_pathv[i]) >= 0xff) continue;
+					if (strlen(g.gl_pathv[i]) >= 0xff)
+						continue;
 
-                                        if (stat(g.gl_pathv[i], &st)) continue;
+					if (stat(g.gl_pathv[i], &st))
+						continue;
 
-                                        if (!S_ISREG(st.st_mode)) continue;
+					if (!S_ISREG(st.st_mode))
+						continue;
 
-                                        ui_current = emperor_get(g.gl_pathv[i]);
+					ui_current = emperor_get(g.gl_pathv[i]);
+
+					if (ui_current) {
+						// check if mtime is changed and the uWSGI instance must be reloaded
+						if (st.st_mtime > ui_current->last_mod) {
+							emperor_respawn(ui_current, st.st_mtime);
+						}
+					}
+					else {
+						emperor_add(g.gl_pathv[i], st.st_mtime, NULL, 0);
+					}
+				}
 
-                                        if (ui_current) {
-                                                // check if mtime is changed and the uWSGI instance must be reloaded
-                                                if (st.st_mtime > ui_current->last_mod) {
-                                                        emperor_respawn(ui_current, st.st_mtime);
-                                                }
-                                        }
-                                        else {
-                                                emperor_add(g.gl_pathv[i], st.st_mtime);
-                                        }
-                                }
-	
 			}
 		}
+		}
 
 		// check for removed instances
 
 		ui_current = ui;
 		has_children = 0;
-                while(ui_current->ui_next) {
-                	ui_current = ui_current->ui_next;
+		while (ui_current->ui_next) {
+			ui_current = ui_current->ui_next;
 			has_children++;
 		}
 
+		if (uwsgi.notify) {
+			if (snprintf(notification_message, 64, "The Emperor is governing %d vassals", has_children) >= 34) {
+				uwsgi_notify(notification_message);
+			}
+		}
+
 		if (has_children) {
 			diedpid = waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 		}
 		else {
+			// vacuum
+			waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
 			diedpid = 0;
 		}
 		if (diedpid < 0) {
 			uwsgi_error("waitpid()");
 		}
 		ui_current = ui;
-        	while(ui_current->ui_next) {
-                	ui_current = ui_current->ui_next;
-			if (ui_current->pid == diedpid) {
-				if (ui_current->status == 0) {
-					// respawn an accidentally dead instance
-					emperor_add(ui_current->name, ui_current->last_mod);
+		while (ui_current->ui_next) {
+			ui_current = ui_current->ui_next;
+			// check loyalty if not in simple/glob mode
+			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) && !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);
+					}
+					break;
+				}
 				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;
 				}
 			}
-			else if (ui_current->status == 1) {
-				emperor_del(ui_current);
-				break;
-			}
-			else if (stat(ui_current->name, &st)) {
-				emperor_stop(ui_current);
-			}
-        	}
+		}
+
 
-		sleep(3);
-		
 	}
-	
+
 }
-
-
-
-

event.c

@@ -6,6 +6,9 @@ extern struct uwsgi_server uwsgi;
 
 #include <port.h>
 
+#define UWSGI_EVENT_IN POLLIN
+#define UWSGI_EVENT_OUT POLLOUT
+
 int event_queue_init() {
 
         int port = port_create();
@@ -18,7 +21,7 @@ int event_queue_init() {
         return port;
 }
 
-int event_queue_del_fd(int eq, int fd) {
+int event_queue_del_fd(int eq, int fd, int event) {
 
         if (port_dissociate(eq, PORT_SOURCE_FD, fd)) {
                 uwsgi_error("port_disassociate");
@@ -28,6 +31,17 @@ int event_queue_del_fd(int eq, int fd) {
         return fd;
 }
 
+int event_queue_fd_write_to_read(int eq, int fd) {
+
+        if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, NULL)) {
+                uwsgi_error("port_associate");
+                return -1;
+        }
+
+        return fd;
+
+}
+
 
 int event_queue_interesting_fd_has_error(void *events, int id) {
 	port_event_t *pe = (port_event_t *) events;
@@ -76,12 +90,11 @@ int event_queue_interesting_fd(void *events, int id) {
 int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
 
         int ret;
-	uint_t nget;
-	int i;
+	uint_t nget = 1;
 	timespec_t ts;
 	port_event_t *pe;
 
-	if (timeout > 0) {
+	if (timeout >= 0) {
                 ts.tv_sec = timeout;
                 ts.tv_nsec = 0;
                 ret = port_getn(eq, events, nevents, &nget, &ts);
@@ -99,13 +112,6 @@ int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
         }
 
 	pe = (port_event_t *) events;
-	for(i=0;i<nget;i++) {
-		if (pe[i].portev_source == PORT_SOURCE_FD) {
-			if (port_associate(eq, pe[i].portev_source, pe[i].portev_object, pe[i].portev_events, NULL)) {
-                		uwsgi_error("port_associate");
-        		}
-		}
-	}
 
         return nget;
 }
@@ -144,7 +150,6 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 
 	if (pe.portev_source == PORT_SOURCE_FILE || pe.portev_source == PORT_SOURCE_TIMER) {
         	*interesting_fd = (int) pe.portev_user;
-		uwsgi_log("port event interesting_fd: %d\n", *interesting_fd);
 	}
 	else {
 		*interesting_fd = (int) pe.portev_object;
@@ -160,6 +165,9 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 
 #include <sys/epoll.h>
 
+#define UWSGI_EVENT_IN EPOLLIN
+#define UWSGI_EVENT_OUT EPOLLOUT
+
 int event_queue_init() {
 
         int epfd;
@@ -207,12 +215,13 @@ int event_queue_fd_write_to_read(int eq, int fd) {
         return fd;
 }
 
-int event_queue_del_fd(int eq, int fd) {
+int event_queue_del_fd(int eq, int fd, int event) {
 
         struct epoll_event ee;
 
         memset(&ee, 0, sizeof(struct epoll_event));
         ee.data.fd = fd;
+	ee.events = event;
 
         if (epoll_ctl(eq, EPOLL_CTL_DEL, fd, &ee)) {
                 uwsgi_error("epoll_ctl()");
@@ -298,6 +307,10 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 #endif
 
 #ifdef UWSGI_EVENT_USE_KQUEUE
+
+#define UWSGI_EVENT_IN EVFILT_READ
+#define UWSGI_EVENT_OUT EVFILT_WRITE
+
 int event_queue_init() {
 
 	int kfd = kqueue();
@@ -329,11 +342,11 @@ int event_queue_fd_write_to_read(int eq, int fd) {
 	return fd;
 }
 
-int event_queue_del_fd(int eq, int fd) {
+int event_queue_del_fd(int eq, int fd, int event) {
 
 	struct kevent kev;
 
-        EV_SET(&kev, fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
+        EV_SET(&kev, fd, event, EV_DELETE, 0, 0, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
                 uwsgi_error("kevent()");
                 return -1;
@@ -516,7 +529,7 @@ int event_queue_add_file_monitor(int eq, char *filename, int *id) {
 
 	int fd = open(filename, O_RDONLY);
 	if (fd < 0) {
-		uwsgi_error("open()");
+		uwsgi_error_open(filename);
 		return -1;
 	}
 	
@@ -578,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);
@@ -617,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++) {
@@ -803,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()");
@@ -831,3 +846,11 @@ struct uwsgi_timer *event_queue_ack_timer(int id) {
 
 }
 #endif
+
+inline int event_queue_read() {
+	return UWSGI_EVENT_IN;
+}
+
+inline int event_queue_write() {
+	return UWSGI_EVENT_OUT;
+}

fibers.ru

@@ -2,10 +2,36 @@ require 'fiber'
 class SuspendingBody
 
 	def each
-		for i in 1..10
+		for i in 1..3
 			yield "number: #{i}\n"
+			UWSGI.async_sleep(1)
+			puts "sleep..."
 			Fiber.yield
 		end
+
+		fd = UWSGI.async_connect("81.174.68.52:80")
+		UWSGI.wait_fd_write(fd, 3)
+		Fiber.yield
+		io = IO.new(fd)
+		puts "connected"
+		io.syswrite("GET /uwsgi/export/1081%3A362d695b2f25/plugins/fiber/fiber.c HTTP/1.0\r\n")
+		io.syswrite("Host: projects.unbit.it\r\n")
+		io.syswrite("\r\n")
+
+		UWSGI.wait_fd_read(fd, 3)
+		Fiber.yield
+
+		puts "data available"
+
+		begin
+		while body = io.sysread(fd)
+			yield body
+			Fiber.yield
+		end
+		rescue
+		end
+	
+		io.close
 	end
 
 end

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()

gateway.c

@@ -55,6 +55,11 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop)(void)) {
 
 	if (!uwsgi.master_process) {
 		if (gw_pid > 0) {
+#ifdef __linux__
+                if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0,0,0)) {
+                        uwsgi_error("prctl()");
+                }
+#endif
 			loop();
 			// never here !!! (i hope)
 			exit(1);	
@@ -101,6 +106,11 @@ void gateway_respawn(int id) {
 
 	if (gw_pid == 0) {
 		if (uwsgi.master_as_root) uwsgi_as_root();
+#ifdef __linux__
+                if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0,0,0)) {
+                        uwsgi_error("prctl()");
+                }
+#endif
 		ug->loop();
 		// never here !!! (i hope)
 		exit(1);	

heavytest.ini

@@ -0,0 +1,27 @@
+[uwsgi]
+
+master = true
+processes = 4
+threads = 8
+
+; initialize 4 sockets with 4 different protocols
+socket = :3031
+socket = :3032
+socket = :3033
+socket = :3034
+
+socket-protocol = 0,uwsgi
+socket-protocol = 1,http
+socket-protocol = 2,fastcgi
+socket-protocol = 3,uwsgidump
+
+
+; add a cache with 1000 items of 96k
+cache = 1000
+cache-blocksize = 98304
+
+
+log-micros = true
+
+module = heavytest
+mount = /cc=uwsgicc/__init__.py

heavytest.py

@@ -0,0 +1,14 @@
+import uwsgi
+import werkzeug.testapp
+
+uwsgi.cache_set("/cache/get", "HTTP 1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<h1>I am the uWSGI cache</h1>")
+
+def app001(env, start_response):
+    start_response('200 OK', [('Content-Type', 'text/html')])
+    return "PATH_INFO=%s" % env['PATH_INFO']
+
+def app002(env, start_response):
+    start_response('200 OK', [('Content-Type', 'text/html')])
+    return "requests: %d" % uwsgi.total_requests()
+
+uwsgi.applications = { '':werkzeug.testapp.test_app, '/app001':app001, '/app002':app002 }

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;
 
 }
@@ -84,11 +89,17 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 
 	int lines = 1;
 
-	struct option *lopt, *aopt;
 	char *section_asked = "uwsgi";
 	char *colon;
 
-	colon = uwsgi_get_last_char(file, ':');
+	if (!uwsgi_startswith(file, "http://", 7)) {
+                colon = uwsgi_get_last_char(file, '/');
+                colon = uwsgi_get_last_char(colon, ':');
+        }
+        else {
+                colon = uwsgi_get_last_char(file, ':');
+        }
+
 	if (colon) {
 		colon[0] = 0;
 		if (colon[1] != 0) {
@@ -96,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);
 
@@ -126,26 +139,7 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 					ini_rstrip(key);
 					val = ini_lstrip(val);
 					ini_rstrip(val);
-					lopt = uwsgi.long_options;
-					while ((aopt = lopt)) {
-						if (!aopt->name)
-							break;
-						if (!strcmp(key, aopt->name)) {
-							if (aopt->flag) {
-								*aopt->flag = aopt->val;
-								add_exported_option(0, (char *)key);
-							}
-							else {
-								if (aopt->has_arg == optional_argument) {
-									if (!strcmp("true", val)) {
-										val = NULL;
-									}
-								}
-								manage_opt(aopt->val, val);
-							}
-						}
-						lopt++;
-					}
+					add_exported_option((char *)key, val, 0);
 				}
 			}
 		}
@@ -156,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>

json.c

@@ -0,0 +1,107 @@
+#ifdef UWSGI_JSON
+
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+#include <jansson.h>
+
+
+/*
+	I really love the jansson library...
+   */
+
+void uwsgi_json_config(char *file, char *magic_table[]) {
+
+	int len = 0;
+	char *json_data;
+
+
+	const char *key;
+
+	json_t *root;
+	json_error_t error;
+	json_t *config;
+	json_t *config_value, *config_array_item;
+
+	void *config_iter;
+
+	char *object_asked = "uwsgi";
+	char *colon;
+	int i;
+
+	if (!uwsgi_startswith(file, "http://", 7)) {
+                colon = uwsgi_get_last_char(file, '/');
+                colon = uwsgi_get_last_char(colon, ':');
+        }
+        else {
+                colon = uwsgi_get_last_char(file, ':');
+        }
+
+	if (colon) {
+		colon[0] = 0;
+		if (colon[1] != 0) {
+			object_asked = colon+1;
+		}
+	}
+
+	uwsgi_log("[uWSGI] getting JSON configuration from %s\n", file);
+
+	json_data = uwsgi_open_and_read(file, &len, 1, magic_table);
+
+	root = json_loads(json_data, 0, &error);
+
+	if (!root) {
+		uwsgi_log("error parsing JSON data: line %d %s\n", error.line, error.text);
+		exit(1);
+	}
+
+	config = json_object_get(root, object_asked);
+
+	if (!json_is_object(config)) {
+		uwsgi_log("you must define a object named %s in your JSON data\n", object_asked);
+		exit(1);
+	}
+	
+	config_iter = json_object_iter(config);
+
+	while(config_iter) {
+		key = json_object_iter_key(config_iter);
+		config_value = json_object_iter_value(config_iter);	
+
+		if (json_is_string(config_value)) {
+			add_exported_option((char *)key, (char *) json_string_value(config_value), 0);
+		}
+		else if (json_is_true(config_value)) {
+			add_exported_option((char *)key, (char *) "1", 0);
+		}
+		else if (json_is_false(config_value) || json_is_null(config_value)) {
+			add_exported_option((char *)key, (char *) "0", 0);
+		}
+		else if (json_is_integer(config_value)) {
+			add_exported_option((char *)key, uwsgi_num2str(json_integer_value(config_value)), 0);
+		}
+		else if (json_is_array(config_value)) {
+			for(i=0;i<(int)json_array_size(config_value);i++) {
+				config_array_item = json_array_get(config_value, i);				
+				if (json_is_string(config_array_item)) {
+                        		add_exported_option((char *)key, (char *) json_string_value(config_array_item), 0);
+                		}
+                		else if (json_is_true(config_array_item)) {
+                        		add_exported_option((char *)key, (char *) "1", 0);
+                		}
+                		else if (json_is_false(config_array_item) || json_is_null(config_array_item)) {
+                        		add_exported_option((char *)key, (char *) "0", 0);
+                		}
+                		else if (json_is_integer(config_array_item)) {
+                        		add_exported_option((char *)key, uwsgi_num2str(json_integer_value(config_array_item)), 0);
+                		}
+			}
+		}
+
+		config_iter = json_object_iter_next(config, config_iter);
+	}
+	
+}
+
+#endif

ldap.c

@@ -6,6 +6,14 @@ extern struct uwsgi_server uwsgi;
 
 #include <ldap.h>
 
+#ifndef LDAP_OPT_SUCCESS
+#define LDAP_OPT_SUCCESS LDAP_SUCCESS
+#endif
+
+#ifndef ldap_unbind_ext_s
+#define ldap_unbind_ext_s ldap_unbind_ext
+#endif
+
 void ldap2uwsgi(char *ldapname, char *uwsginame) {
 	char *ptr = uwsginame;
 
@@ -37,71 +45,162 @@ int calc_ldap_name(char *name) {
 	return strlen(name) + counter;
 }
 
-void uwsgi_ldap_schema_dump_ldif() {
-	struct option *aopt, *lopt;
+struct uwsgi_ldap_entry {
+	int num;
+	char names[1024];
+	int has_arg;
+};
+
+
+void uwsgi_name_to_ldap(char *src, char *dst) {	
 
-	lopt = uwsgi.long_options;
 	int i;
-	int counter = 30000;
+	char *ptr = dst;
+
+	memset(dst, 0, 1024);
+
+	strcat(dst, " 'uWSGI");
+
+	ptr+= 7;
+
+	for(i=0;i< (int)strlen(src);i++) {
+        	if (src[i] == '-') {
+                	i++;
+                        *ptr++= toupper( (int) src[i]);
+                }
+                else {
+                	*ptr++= src[i];
+                }
+	}
+
+	strcat(dst, "'");
+
+}
+
+struct uwsgi_ldap_entry *get_ldap_by_num(struct uwsgi_ldap_entry *root, int num, int count) {
+
+	int i;
+	struct uwsgi_ldap_entry *ule;
+
+	for(i=0;i<count;i++) {
+		ule = &root[i];
+		if (ule->num == num) {
+			return ule;
+		}
+	}
+
+	return NULL;
+}
+
+struct uwsgi_ldap_entry *search_ldap_cache(struct uwsgi_ldap_entry *root, char *name, int count) {
+	int i;
+	struct uwsgi_ldap_entry *ule;
+
+	for(i=0;i<count;i++) {
+		ule = &root[i];
+		if (uwsgi_list_has_str(ule->names, name+1)) {
+			return ule;
+		}
+	}
+
+	return NULL;
+}
+
+struct uwsgi_ldap_entry *get_ldap_names(int *count) {
+
+	struct option *aopt, *lopt;
+	struct uwsgi_ldap_entry *ule, *entry;
+	char ldap_name[1024];
+	static int counter = 30000000;
+
+	*count = 0;
+	lopt = uwsgi.long_options;
+
+	ule = uwsgi_malloc(sizeof(struct uwsgi_ldap_entry)*count_options(lopt));
+
+	while( (aopt = lopt) ) {
+                if (!aopt->name)
+                        break;
+
+		uwsgi_name_to_ldap((char *)aopt->name, ldap_name);
+
+		entry = search_ldap_cache(ule, ldap_name, *count);
+
+		if (entry) goto next;
+
+		if (aopt->flag) {
+			entry = &ule[*count] ;
+			entry->num = counter;
+			strcpy(entry->names, ldap_name);
+			counter++;
+			*count = *count+1;
+		}
+		else {
+			entry = get_ldap_by_num(ule, aopt->val, *count);
+			if (entry) {
+				strcat(entry->names, ldap_name);
+			}
+			else {
+				entry = &ule[*count] ;
+				entry->num = aopt->val;
+				strcpy(entry->names, ldap_name);
+				*count = *count+1;
+			}
+		}
+
+		entry->has_arg = aopt->has_arg;
+		
+next:
+		lopt++;
+	}
+
+	return ule;
+}
+
+void uwsgi_ldap_schema_dump_ldif() {
+
+	int i;
+	int items;
 
 	uwsgi_log("\n");
 	uwsgi_log("dn: cn=uwsgi,cn=schema,cn=config\n");
 	uwsgi_log("objectClass: olcSchemaConfig\n");
 	uwsgi_log("cn: uwsgi\n");
 
-	while( (aopt = lopt) ) {
-		if (!aopt->name)
-			break;
+	struct uwsgi_ldap_entry *entry, *ule = get_ldap_names(&items);
 
-		if (aopt->flag) {
-			uwsgi_log("olcAttributeTypes: ( 1.3.6.1.4.1.35156.17.4.%d NAME 'uWSGI", counter);
-			counter++;
+	for(i=0;i<items;i++) {
+
+		entry = &ule[i];
+		uwsgi_log("olcAttributeTypes: ( 1.3.6.1.4.1.35156.17.4.%d NAME (%s", entry->num, entry->names);
+
+		if (entry->has_arg) {
+			uwsgi_log(" ) SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )\n");
 		}
 		else {
-			uwsgi_log("olcAttributeTypes: ( 1.3.6.1.4.1.35156.17.4.%d NAME 'uWSGI", aopt->val);
+			uwsgi_log(" ) SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
 		}
-		for(i=0;i< (int)strlen(aopt->name);i++) {
-			if (aopt->name[i] == '-') {
-				i++;
-				uwsgi_log("%c", toupper( (int) aopt->name[i]));
-			}
-			else {
-				uwsgi_log("%c", aopt->name[i]);
-			}
-		}
-
-		if (aopt->has_arg) {
-			uwsgi_log("' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )\n");
-		}
-		else {
-			uwsgi_log("' SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
-		}
-		lopt++;
 	}
 
 	uwsgi_log("olcAttributeTypes: ( 1.3.6.1.4.1.35156.17.4.50000 NAME 'uWSGInull' SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
 
-	lopt = uwsgi.long_options;
 
 	uwsgi_log("olcObjectClasses: ( 1.3.6.1.4.1.35156.17.3.1 NAME 'uWSGIConfig' SUP top AUXILIARY DESC 'uWSGI configuration' MAY ( ");
 
-	while( (aopt = lopt) ) {
-		if (!aopt->name)
-			break;
+	
+	for(i=0;i<items;i++) {
 
-		uwsgi_log("uWSGI");
+                entry = &ule[i];
+
+		char *list2 = uwsgi_concat2(entry->names+1, "");
+		char *p = strtok(list2, " ");
+        	while (p != NULL) {
+			uwsgi_log("%.*s $ ", strlen(p)-2, p+1);
+                	p = strtok(NULL, " ");
+        	}
+
+        	free(list2);
 
-		for(i=0;i< (int)strlen(aopt->name);i++) {
-			if (aopt->name[i] == '-') {
-				i++;
-				uwsgi_log("%c", toupper( (int) aopt->name[i]));
-			}
-			else {
-				uwsgi_log("%c", aopt->name[i]);
-			}
-		}
-		uwsgi_log(" $ ");
-		lopt++;
 	}
 
 	uwsgi_log("uWSGInull ))\n");
@@ -112,67 +211,47 @@ void uwsgi_ldap_schema_dump_ldif() {
 }
 
 void uwsgi_ldap_schema_dump() {
-	struct option *aopt, *lopt;
 
-	lopt = uwsgi.long_options;
 	int i;
-	int counter = 30000;
+	int items;
 
-	while( (aopt = lopt) ) {
-		if (!aopt->name)
-			break;
+	struct uwsgi_ldap_entry *entry, *ule = get_ldap_names(&items);
 
+        for(i=0;i<items;i++) {
 
-		if (aopt->flag) {
-			uwsgi_log("attributetype ( 1.3.6.1.4.1.35156.17.4.%d NAME 'uWSGI", counter);
-			counter++;
-		}
-		else {
-			uwsgi_log("attributetype ( 1.3.6.1.4.1.35156.17.4.%d NAME 'uWSGI", aopt->val);
-		}
-		for(i=0;i< (int)strlen(aopt->name);i++) {
-			if (aopt->name[i] == '-') {
-				i++;
-				uwsgi_log("%c", toupper( (int) aopt->name[i]));
-			}
-			else {
-				uwsgi_log("%c", aopt->name[i]);
-			}
-		}
+                entry = &ule[i];
+                uwsgi_log("attributetype ( 1.3.6.1.4.1.35156.17.4.%d NAME (%s", entry->num, entry->names);
+
+                if (entry->has_arg) {
+                        uwsgi_log(" ) SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )\n");
+                }
+                else {
+                        uwsgi_log(" ) SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
+                }
+        }
 
-		if (aopt->has_arg) {
-			uwsgi_log("' SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )\n");
-		}
-		else {
-			uwsgi_log("' SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
-		}
-		lopt++;
-	}
 
 	uwsgi_log("attributetype ( 1.3.6.1.4.1.35156.17.4.50000 NAME 'uWSGInull' SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )\n");
 
-	lopt = uwsgi.long_options;
-
 	uwsgi_log("objectclass ( 1.3.6.1.4.1.35156.17.3.1 NAME 'uWSGIConfig' SUP top AUXILIARY DESC 'uWSGI configuration' MAY ( ");
 
-	while( (aopt = lopt) ) {
-		if (!aopt->name)
-			break;
+	for(i=0;i<items;i++) {
+
+                entry = &ule[i];
+
+                char *list2 = uwsgi_concat2(entry->names+1, "");
+                char *p = strtok(list2, " ");
+                while (p != NULL) {
+                        uwsgi_log("%.*s $ ", strlen(p)-2, p+1);
+                        p = strtok(NULL, " ");
+                }
+
+                free(list2);
+
+        }
+
 
-		uwsgi_log("uWSGI");
 
-		for(i=0;i< (int)strlen(aopt->name);i++) {
-			if (aopt->name[i] == '-') {
-				i++;
-				uwsgi_log("%c", toupper( (int) aopt->name[i]));
-			}
-			else {
-				uwsgi_log("%c", aopt->name[i]);
-			}
-		}
-		uwsgi_log(" $ ");
-		lopt++;
-	}
 
 	uwsgi_log("uWSGInull ))\n");
 
@@ -194,8 +273,6 @@ void uwsgi_ldap_config() {
 	int desired_version = LDAP_VERSION3;
 	int ret;
 
-	struct option *aopt, *lopt;
-
 	LDAPURLDesc *ldap_url;
 
 	if (uwsgi.ldap) {
@@ -211,6 +288,8 @@ void uwsgi_ldap_config() {
 		uwsgi_log("unable to parse LDAP url.\n");
 		exit(1);
 	}
+	
+	uwsgi_log("[uWSGI] getting LDAP configuration from %s\n", url);
 
 	url_slash = strchr(url, '/');
 	url_slash = strchr(url_slash + 1, '/');
@@ -225,10 +304,17 @@ void uwsgi_ldap_config() {
 	uwsgi_debug("LDAP BASE DN: %s\n", ldap_url->lud_dn);
 #endif
 
+#if LDAP_API_VERSION >= 3000
 	if ( (ret = ldap_initialize( &ldp, url)) != LDAP_SUCCESS) {
 		uwsgi_log("LDAP: %s\n", ldap_err2string(ret));
 		exit(1);
 	}
+#else
+	if ( (ldp = ldap_init( ldap_url->lud_host, ldap_url->lud_port)) == NULL) {
+		uwsgi_error("ldap_init()");
+		exit(1);
+	}
+#endif
 
 
 	if ( (ret = ldap_set_option(ldp, LDAP_OPT_PROTOCOL_VERSION, &desired_version)) != LDAP_OPT_SUCCESS) {
@@ -255,9 +341,11 @@ void uwsgi_ldap_config() {
 
 	entry = ldap_first_entry(ldp, results);
 
+	int found = 0;
 	for( attr = ldap_first_attribute(ldp, entry, &ber); attr != NULL; attr = ldap_next_attribute(ldp, entry, ber)) {
 		if (!strncmp(attr,"uWSGI",5)) {
 
+			found = 1;
 			uwsgi_attr = malloc( calc_ldap_name(attr) + 1 );
 			if (!uwsgi_attr) {
 				uwsgi_error("malloc()");
@@ -271,7 +359,7 @@ void uwsgi_ldap_config() {
 #endif
 			bervalues = ldap_get_values_len(ldp, entry, attr);
 			if (bervalues) {
-				// do not free uwsgi_val;
+				// do not free uwsgi_attr/uwsgi_val;
 				char *uwsgi_val = malloc( bervalues[0]->bv_len + 1 );
 				if (!uwsgi_val) {
 					uwsgi_error("malloc()");
@@ -281,29 +369,21 @@ void uwsgi_ldap_config() {
 				memcpy(uwsgi_val, bervalues[0]->bv_val, bervalues[0]->bv_len);
 				uwsgi_val[bervalues[0]->bv_len] = 0;
 
-				lopt = uwsgi.long_options;
-				while ((aopt = lopt)) {
-					if (!aopt->name)
-						break;
-					if (!strcmp(uwsgi_attr, aopt->name)) {
-						if (aopt->flag) {
-							*aopt->flag = aopt->val;
-							add_exported_option(0, (char*) uwsgi_attr);
-						}
-						else {
-							manage_opt(aopt->val, uwsgi_val);
-						}
-					}
-					lopt++;
-				}
+				add_exported_option((char*) uwsgi_attr, uwsgi_val, 0);
+				free(bervalues);
+			}
+			else {
+				free(uwsgi_attr);
 			}
-
-			free(bervalues);
-			free(uwsgi_attr);
 		}
 		free(attr);
 	}
 
+	if (!found) {
+		uwsgi_log("no uWSGI LDAP entry found\n");
+		exit(1);
+	}
+
 	free(ber);
 	free(results);
 

lib/amqp.c

@@ -0,0 +1,806 @@
+#include "../uwsgi.h"
+
+#define AMQP_CONNECTION_HEADER "AMQP\0\0\x09\x01"
+
+#ifdef __BIG_ENDIAN__
+#define ntohll(x) x
+#else
+#define ntohll(x) ( ( (uint64_t)(ntohl( (uint32_t)((x << 32) >> 32) )) << 32) | ntohl( ((uint32_t)(x >> 32)) ) )     
+#endif
+#define htonll(x) ntohll(x)
+
+#define amqp_send(a, b, c) if (send(a, b, c, 0) < 0) { uwsgi_error("send()"); return -1; }
+
+struct amqp_frame_header {
+
+	char type;
+	uint16_t channel;
+	uint32_t size;
+
+} __attribute__((__packed__));
+
+struct amqp_frame_method {
+	uint16_t class_id;
+	uint16_t method_id;
+} __attribute__((__packed__));
+
+static char *amqp_simple_get_frame(int, struct amqp_frame_header *);
+static char *amqp_get_method(int, uint16_t, uint16_t, uint32_t *);
+
+/*
+static char *amqp_get_longstr(char *ptr, char *watermark) {
+
+        uint32_t longstr_size;
+
+	if (ptr+4 > watermark) return NULL;
+
+        memcpy(&longstr_size, ptr, 4);
+        longstr_size = ntohl(longstr_size);
+
+	if (ptr+4+longstr_size > watermark) return NULL;
+
+        return ptr+4+longstr_size;
+}
+*/
+
+static char *amqp_get_str(char *ptr, char *watermark) {
+
+        uint8_t str_size;
+
+	// over engeneering...
+	if (ptr+1 > watermark) return NULL;
+
+        str_size = *ptr;
+
+	if (ptr+1+str_size > watermark) return NULL;
+
+        return ptr+1+str_size;
+}
+
+
+/*
+static char *amqp_get_table(char *ptr, char *watermark) {
+
+	uint32_t table_size;
+
+	if (ptr+4 > watermark) return NULL;
+
+	memcpy(&table_size, ptr, 4);
+
+	table_size = ntohl(table_size);
+
+	if (ptr+4+table_size > watermark) return NULL;
+
+	return ptr+4+table_size;
+}
+*/
+
+static char *amqp_get_short(char *ptr, char *watermark, uint16_t *sv) {
+
+	uint16_t tmp_short;
+
+	if (ptr+2 > watermark) return NULL;
+
+	memcpy(&tmp_short, ptr, 2);
+
+	*sv = ntohs(tmp_short);
+
+	return ptr+2;
+}
+
+static char *amqp_get_long(char *ptr, char *watermark, uint32_t *lv) {
+
+	uint32_t tmp_long;
+
+	if (ptr+4 > watermark) return NULL;
+
+	memcpy(&tmp_long, ptr, 4);
+
+	*lv = ntohl(tmp_long);
+	return ptr+4;
+}
+
+static char *amqp_get_longlong(char *ptr, char *watermark, uint64_t *llv) {
+
+        uint64_t tmp_longlong;
+
+	if (ptr+8 > watermark) return NULL;
+
+        memcpy(&tmp_longlong, ptr, 8);
+
+        *llv = ntohll(tmp_longlong);
+        return ptr+8;
+}
+
+
+
+static int amqp_send_ack(int fd, uint64_t delivery_tag) {
+
+	uint32_t size = 4 + 8 + 1;
+
+        size = htonl(size);
+        // send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 60 method 80
+        amqp_send(fd, "\x00\x3C\x00\x50", 4);
+
+	// set delivery_tag
+	delivery_tag = htonll(delivery_tag);
+	amqp_send(fd, &delivery_tag, 8);
+
+        // empty bits
+        amqp_send(fd, "\0", 1);
+
+        // send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+	return 0;
+}
+
+char *uwsgi_amqp_consume(int fd, uint64_t *msgsize, char **routing_key) {
+
+	uint32_t size;
+	struct amqp_frame_header fh;
+	uint64_t delivery_tag;
+	uint64_t current_size = 0;
+	char *ptr;
+	char *watermark;
+	uint16_t sv;
+
+	char *frame = amqp_get_method(fd, 60, 60, &size);
+	if (!frame) return NULL;
+
+	ptr = frame+4;
+	watermark = frame+size;
+
+	// consumer_tag
+	ptr = amqp_get_str(ptr, watermark); if (!ptr) goto clear;
+	// delivery_tag (needed for ack)
+        ptr = amqp_get_longlong(ptr, watermark, &delivery_tag); if (!ptr) goto clear;
+	// redelivered
+	if (ptr+1 > watermark) goto clear;
+	ptr++;
+	// exchange
+	ptr = amqp_get_str(ptr, watermark); if (!ptr) goto clear;
+	// routing_key
+	if (ptr+1 > watermark) goto clear;
+	uint8_t rk_size = (uint8_t) *ptr;
+	ptr++;
+	if (ptr+rk_size > watermark) goto clear;
+
+	if (rk_size > 0) {
+		char *rkey = uwsgi_concat2n(ptr, rk_size, "", 0);
+		ptr+=rk_size;
+
+		*routing_key = rkey;	
+	}
+	else {
+		*routing_key = NULL;
+	}
+	
+	char *header = amqp_simple_get_frame(fd, &fh);
+	if (!header) goto clear;
+
+	if (fh.type != 2) goto clear2;
+
+	ptr = header;
+	watermark = ptr+fh.size;
+
+	// header class_id
+        ptr = amqp_get_short(ptr, watermark, &sv); if (!ptr) goto clear2;
+        // header weight
+        ptr = amqp_get_short(ptr, watermark, &sv); if (!ptr) goto clear2;
+	// message size;
+        ptr = amqp_get_longlong(ptr, watermark, msgsize); if (!ptr) goto clear2;
+
+	free(frame);
+	free(header);
+
+	char *fullbody = uwsgi_malloc(*msgsize);
+	char *message;
+
+	while(current_size < *msgsize) {
+		message = amqp_simple_get_frame(fd, &fh);
+		if (!message) goto clear;
+
+		if (fh.type != 3) {
+			free(message);
+			goto clear3;
+		}
+
+		if (fh.size+current_size > *msgsize) {
+			free(message);
+			goto clear3;
+		}
+
+		memcpy(fullbody+current_size, message, fh.size);
+		current_size+=fh.size;
+		free(message);
+	}
+
+	if (amqp_send_ack(fd, delivery_tag) < 0) {
+		goto clear3;
+	}
+
+	return fullbody;
+
+clear3:
+	free(fullbody);
+	return NULL;
+
+clear2:
+	free(header);
+clear:
+	free(frame);
+	return NULL;
+	
+}
+
+static int amqp_send_exchange_declare( int fd, char *exchange, char *exchange_type) {
+
+        uint32_t size = 4 + 2 + (1 +strlen(exchange)) + (1 +strlen(exchange_type)) + 1 + 4;
+        uint8_t shortsize = strlen(exchange) ;
+
+        size = htonl(size);
+        // send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 40 method 10
+        amqp_send(fd, "\x00\x28\x00\x0A", 4);
+
+        // send empty reserved
+        amqp_send(fd, "\0\0", 2);
+
+        // set exchange name
+        amqp_send(fd, &shortsize, 1);
+        amqp_send(fd, exchange, shortsize);
+
+        // set exchange type
+        shortsize = strlen(exchange_type);
+        amqp_send(fd, &shortsize, 1);
+        amqp_send(fd, exchange_type, shortsize);
+
+        // empty bits
+        amqp_send(fd, "\0", 1);
+        // empty table
+        amqp_send(fd, "\0\0\0\0", 4);
+
+        // send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+        return 0;
+}
+
+
+static int amqp_send_queue_bind( int fd, char *queue, char *exchange) {
+
+        uint32_t size = 4 + 2 + (1 +strlen(queue)) + (1 +strlen(exchange)) + 1 + 1 + 4;
+        uint8_t shortsize = strlen(queue) ;
+
+        size = htonl(size);
+        // send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 50 method 20
+        amqp_send(fd, "\x00\x32\x00\x14", 4);
+
+        // send empty reserved
+        amqp_send(fd, "\0\0", 2);
+
+        // set queue name
+        amqp_send(fd, &shortsize, 1);
+        amqp_send(fd, queue, shortsize);
+
+        // set exchange name
+        shortsize = strlen(exchange);
+        amqp_send(fd, &shortsize, 1);
+        amqp_send(fd, exchange, shortsize);
+
+	// set empty routing-key
+        amqp_send(fd, "\0", 1);
+
+        // empty bits
+        amqp_send(fd, "\0", 1);
+        // empty table
+        amqp_send(fd, "\0\0\0\0", 4);
+
+        // send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+        return 0;
+}
+
+
+static int amqp_send_queue_consume( int fd, char *queue) {
+
+	uint32_t size = 4 + 2 + (1 +strlen(queue)) + 1 + 1 + 4;
+        uint8_t shortsize = strlen(queue) ;
+
+        size = htonl(size);
+        // send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 60 method 20
+        amqp_send(fd, "\x00\x3C\x00\x14", 4);
+
+        // send empty reserved
+        amqp_send(fd, "\0\0", 2);
+
+        // set queue name
+        amqp_send(fd, &shortsize, 1);
+        amqp_send(fd, queue, shortsize);
+
+        // set tag name
+        amqp_send(fd, "\0", 1);
+
+        // empty bits
+        amqp_send(fd, "\0", 1);
+        // empty table
+        amqp_send(fd, "\0\0\0\0", 4);
+
+        // send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+	return 0;
+}
+
+static int amqp_wait_connection_start(int fd) {
+	uint32_t size;
+	char *frame = amqp_get_method(fd, 10, 10, &size);
+
+	if (frame) {
+		free(frame);
+		return 0;
+	}
+
+	return -1;
+}
+
+static int amqp_wait_exchange_declare_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 40, 11, &size);
+
+        if (frame) {
+                free(frame);
+                return 0;
+        }
+
+        return -1;
+}
+
+
+static int amqp_wait_basic_consume_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 60, 21, &size);
+
+        if (frame) {
+                free(frame);
+                return 0;
+        }
+
+        return -1;
+}
+
+
+static int amqp_wait_channel_open_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 20, 11, &size);
+
+        if (frame) {
+                free(frame);
+                return 0;
+        }
+
+        return -1;
+}
+
+static int amqp_wait_queue_bind_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 50, 21, &size);
+
+        if (frame) {
+                free(frame);
+                return 0;
+        }
+
+        return -1;
+}
+
+
+static char *amqp_wait_queue_declare_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 50, 11, &size);
+	char *queue = NULL;
+	char *ptr;
+	char *watermark;
+
+        if (frame) {
+
+		ptr = frame+4;
+		watermark = frame+size;
+
+		ptr = amqp_get_str(ptr, watermark); if (!ptr) { free(frame); return NULL; }
+
+                queue = uwsgi_concat2n(frame+5, *(frame+4), "", 0);
+		
+                free(frame);
+                return queue;
+        }
+
+        return NULL;
+}
+
+
+static int amqp_wait_connection_open_ok(int fd) {
+        uint32_t size;
+        char *frame = amqp_get_method(fd, 10, 41, &size);
+
+        if (frame) {
+                free(frame);
+                return 0;
+        }
+
+        return -1;
+}
+
+
+static int amqp_wait_connection_tune(int fd) {
+
+	uint32_t size;
+	char *frame = amqp_get_method(fd, 10, 30, &size);
+
+	uint16_t sv;
+	uint32_t lv;
+	char *watermark ;
+	char *ptr;
+
+
+	if (frame) {
+		ptr = frame+4;
+		watermark = frame+size;
+		ptr = amqp_get_short(ptr, watermark, &sv); if (!ptr) { free(frame); return -1; }
+        	uwsgi_log("AMQP max channels: %d\n", sv);
+        	ptr = amqp_get_long(ptr, watermark, &lv); if (!ptr) { free(frame); return -1; }
+        	uwsgi_log("AMQP max frame size: %d\n", lv);
+        	ptr = amqp_get_short(ptr, watermark, &sv); if (!ptr) { free(frame); return -1; }
+        	uwsgi_log("AMQP heartbeath: %d\n", sv);
+
+		free(frame);
+		return 0;
+	}
+
+	return -1;
+}
+
+static char *amqp_simple_get_frame(int fd, struct amqp_frame_header *fh) {
+
+	char *ptr = (char *) fh;
+        size_t len = 0, rlen;
+
+        while(len < 7) {
+                rlen = recv(fd, ptr, 7-len, 0);
+                if (rlen <= 0) {
+                        uwsgi_error("recv()");
+                        return NULL;
+                }
+                len += rlen;
+                ptr += rlen;
+        }
+
+        fh->channel = ntohs(fh->channel);
+        fh->size = ntohl(fh->size);
+
+        len = 0;
+
+        char *frame = malloc(fh->size+1);
+        ptr = frame;
+
+        while(len < fh->size+1) {
+                rlen = recv(fd, ptr, (fh->size+1)-len, 0);
+                if (rlen <= 0) {
+                        uwsgi_error("recv()");
+                        return NULL;
+                }
+                len += rlen;
+                ptr += rlen;
+        }
+
+	return frame;
+}
+
+static char *amqp_get_method(int fd, uint16_t class_id, uint16_t method_id, uint32_t *size) {
+
+	struct amqp_frame_header fh;
+        struct amqp_frame_method *fm;
+
+        char *frame = amqp_simple_get_frame(fd, &fh);
+        if (!frame) return NULL;
+
+	if (fh.type != 1) goto clear;
+
+	fm = (struct amqp_frame_method *) frame;
+	fm->class_id = ntohs(fm->class_id);
+	fm->method_id = ntohs(fm->method_id);
+
+	if (fm->class_id != class_id) goto clear;
+	if (fm->method_id != method_id) goto clear;
+
+	*size = fh.size;
+	return frame;
+
+clear:
+
+	free(frame);
+	return NULL;
+}
+
+static int amqp_send_channel_open(int fd, uint16_t id) {
+	
+	uint32_t size = 4 + 1;
+	size = htonl(size);
+	// send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+	// send size
+        amqp_send(fd, &size, 4);
+
+        // send class 20 method 10
+        amqp_send(fd, "\x00\x14\x00\x0A", 4);
+
+	amqp_send(fd, "\0", 1);
+	// send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+	return 0;
+}
+
+int amqp_send_connection_open(int fd, char *vhost) {
+
+	uint8_t shortsize = strlen(vhost);
+	uint32_t size = 4 + 1 +strlen(vhost) + 2;
+	size = htonl(size);
+
+        // send type and channel
+        amqp_send(fd, "\1\0\0", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 10 method 28
+        amqp_send(fd, "\x00\x0A\x00\x28", 4);
+
+	amqp_send(fd, &shortsize, 1);
+	amqp_send(fd, vhost, strlen(vhost));
+
+	shortsize = 0;
+	amqp_send(fd, &shortsize, 1);
+	amqp_send(fd, &shortsize, 1);
+	// send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+	return 0;
+
+}
+
+int amqp_send_connection_tune_ok(int fd, uint16_t max_chan, uint32_t max_frame_size, uint16_t heartbeat) {
+
+	uint32_t size = 4 + 2 + 4 + 2;
+	size = htonl(size);
+
+	max_chan = htons(max_chan);
+	max_frame_size = htonl(max_frame_size);
+	heartbeat = htons(heartbeat);
+
+	// send type and channel
+	amqp_send(fd, "\1\0\0", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+        // send class 10 method 15
+        amqp_send(fd, "\x00\x0A\x00\x1F", 4);	
+
+	amqp_send(fd, &max_chan, 2);
+	amqp_send(fd, &max_frame_size, 4);
+	amqp_send(fd, &heartbeat, 2);
+
+	// send frame-end
+	amqp_send(fd, "\xCE", 1);
+
+	return 0;
+
+}
+
+
+static int amqp_send_queue_declare(int fd, char *queue) {
+
+	uint32_t size = 4 + 2 + (1 +strlen(queue)) + 1 + 4;
+	uint8_t shortsize = strlen(queue) ;
+	
+	size = htonl(size);
+        // send type and channel
+        amqp_send(fd, "\1\0\1", 3);
+        // send size
+        amqp_send(fd, &size, 4);
+
+	// send class 50 method 10
+        amqp_send(fd, "\x00\x32\x00\x0A", 4);
+
+	// send empty reserved
+	amqp_send(fd, "\0\0", 2);
+
+	// set queue name
+	amqp_send(fd, &shortsize, 1);
+	amqp_send(fd, queue, shortsize);
+
+	// empty bits
+	amqp_send(fd, "\0", 1);
+	// empty table
+	amqp_send(fd, "\0\0\0\0", 4);
+
+	// send frame-end
+        amqp_send(fd, "\xCE", 1);
+
+	return 0;
+}
+
+static char *amqp_get_queue(int fd, char *queue) {
+
+	if (amqp_send_queue_declare(fd, queue) < 0) {
+		return NULL;
+	}
+
+	return amqp_wait_queue_declare_ok(fd);
+}
+
+
+static int amqp_send_connection_start_ok(int fd, char *mech, char *sasl_response, int sasl_response_size, char *locale) {
+
+	uint32_t size = 4 + 4 + (1 +strlen(mech)) + (4 + sasl_response_size) + (1 + strlen(locale));
+	uint8_t shortsize ;
+
+	size = htonl(size);
+	// send type and channel
+	amqp_send(fd, "\1\0\0", 3);
+	// send size
+	amqp_send(fd, &size, 4);
+
+	// send class 10 method 11
+	amqp_send(fd, "\x00\x0A\x00\x0B", 4);
+
+	// send empty client properties
+	amqp_send(fd, "\0\0\0\0", 4);
+
+	// send mechanism short string
+	shortsize = strlen(mech);
+	amqp_send(fd, &shortsize, 1);
+	amqp_send(fd, mech, strlen(mech));
+
+	// send sasl response
+	size = htonl(sasl_response_size);
+	amqp_send(fd, &size, 4);
+	amqp_send(fd, sasl_response, sasl_response_size);
+
+	// send locale
+	shortsize = strlen(locale);
+	amqp_send(fd, &shortsize, 1);
+	amqp_send(fd, locale, strlen(locale));
+
+	// send frame-end
+	amqp_send(fd, "\xCE", 1);
+	
+	return 0;
+	
+}
+
+int uwsgi_amqp_consume_queue(int fd, char *vhost, char *username, char *password, char *queue, char *exchange, char *exchange_type) {
+
+	char *auth = uwsgi_concat4n("\0",1, username, strlen(username), "\0",1, password, strlen(password));
+
+	if (send(fd, AMQP_CONNECTION_HEADER, 8, 0) < 0) {
+		uwsgi_error("send()");
+		return -1;
+	}
+
+	if (amqp_wait_connection_start(fd) < 0) {
+		uwsgi_log("AMQP error waiting for Connection.start\n");
+		return -1;
+	}
+
+	uwsgi_log("sending Connection.start-ok\n");
+	if (amqp_send_connection_start_ok(fd, "PLAIN", auth, strlen(username)+strlen(password)+2, "en_US") < 0) {
+		free(auth);
+		uwsgi_log("AMQP error sending Connection.start-ok\n");
+		return -1;
+	}
+
+	free(auth);
+
+	if (amqp_wait_connection_tune(fd) < 0) {
+		uwsgi_log("AMQP error waiting for Connection.tune\n");
+		return -1;
+	}
+
+	uwsgi_log("sending Connection.tune-ok\n");
+	if (amqp_send_connection_tune_ok(fd, 0, 0xffff, 0) < 0) {
+		uwsgi_log("AMQP error sending Connection.tune-ok\n");
+		return -1;
+	}
+
+	uwsgi_log("sending Connection.open\n");
+	if (amqp_send_connection_open(fd, vhost) < 0) {
+		uwsgi_log("AMQP error sending Connection.open\n");
+		return -1;
+	}
+
+	if (amqp_wait_connection_open_ok(fd) < 0) {
+		uwsgi_log("AMQP error waiting for Connection.open-ok\n");
+		return -1;
+	}
+
+	uwsgi_log("sending Channel.open\n");
+	if (amqp_send_channel_open(fd, 1) < 0) {
+		uwsgi_log("AMQP error sending Channel.open\n");
+		return -1;
+	}
+
+	if (amqp_wait_channel_open_ok(fd) < 0) {
+		uwsgi_log("AMQP error waiting for Channel.open-ok\n");
+		return -1;
+	}
+
+	queue = amqp_get_queue(fd, queue);
+	if (!queue) {
+		uwsgi_log("AMQP error sending Queue.declare\n");
+		return -1;
+	}
+
+	if (exchange) {
+		if (amqp_send_exchange_declare(fd, exchange, exchange_type) < 0) {
+			uwsgi_log("AMQP error sending Exchange.declare\n");
+			free(queue);
+                        return -1;
+		}
+
+		if (amqp_wait_exchange_declare_ok(fd) < 0) {
+			uwsgi_log("AMQP error waiting for Exchange.declare-ok\n");
+			free(queue);
+                        return -1;
+		}
+
+		if (amqp_send_queue_bind(fd, queue, exchange) < 0) {
+			uwsgi_log("AMQP error sending Queue.bind\n");
+			free(queue);
+                        return -1;
+                }
+
+		if (amqp_wait_queue_bind_ok(fd) < 0) {
+			uwsgi_log("AMQP error waiting for Queue.bind-ok\n");
+			free(queue);
+                        return -1;
+		}
+	}
+
+	if (amqp_send_queue_consume(fd, queue) < 0) {
+		uwsgi_log("AMQP error sending Basic.consume\n");
+        	free(queue);
+                return -1;
+	}
+
+	if (amqp_wait_basic_consume_ok(fd) < 0) {
+		uwsgi_log("AMQP error waiting for Basic.consume-ok\n");
+        	free(queue);
+                return -1;
+	}
+	
+	free(queue);
+
+	uwsgi_log("AMQP subscription done, waiting for events...\n");
+	return 0;
+}

lib/linux_ns.c

@@ -0,0 +1,149 @@
+#include "../uwsgi.h"
+
+
+extern struct uwsgi_server uwsgi;
+
+#ifndef CLONE_NEWUTS
+#define CLONE_NEWUTS 0x04000000
+#endif
+
+#ifndef CLONE_NEWPID
+#define CLONE_NEWPID 0x20000000
+#endif
+
+#ifndef CLONE_NEWIPC
+#define CLONE_NEWIPC 0x08000000
+#endif
+
+#ifndef CLONE_NEWNET
+#define CLONE_NEWNET 0x40000000
+#endif
+
+void linux_namespace_start(void *argv) {
+	for (;;) {
+		char stack[PTHREAD_STACK_MIN];
+		int waitpid_status;
+		uwsgi_log("*** jailing uWSGI in %s ***\n", uwsgi.ns);
+		int clone_flags = SIGCHLD | CLONE_NEWUTS | CLONE_NEWPID | CLONE_NEWIPC | CLONE_NEWNS;
+		if (uwsgi.ns_net) {
+			clone_flags |= CLONE_NEWNET;
+		}
+		pid_t pid = clone(uwsgi_start, stack + PTHREAD_STACK_MIN, clone_flags, (void *) argv);
+		if (pid == -1) {
+			uwsgi_error("clone()");
+			exit(1);
+		}
+		uwsgi_log("waiting for jailed master (pid: %d) death...\n", (int) pid);
+		pid = waitpid(pid, &waitpid_status, 0);
+		if (pid < 0) {
+			uwsgi_error("waitpid()");
+			exit(1);
+		}
+
+		// in Linux this is reliable
+		if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == 1) {
+			exit(1);
+		}
+
+		uwsgi_log("pid %d ended. Respawning...\n", (int) pid);
+	}
+
+	// never here
+}
+
+
+
+void linux_namespace_jail() {
+
+	char *ns_tmp_mountpoint = NULL, *ns_tmp_mountpoint2 = NULL;
+
+	if (getpid() != 1) {
+		uwsgi_log("your kernel does not support linux pid namespace\n");
+		exit(1);
+	}
+
+	char *ns_hostname = strchr(uwsgi.ns, ':');
+	if (ns_hostname) {
+		ns_hostname[0] = 0;
+		ns_hostname++;
+		if (sethostname(ns_hostname, strlen(ns_hostname))) {
+			uwsgi_error("sethostname()");
+		}
+	}
+
+	FILE *procmounts;
+	char line[1024];
+	int unmounted = 1;
+	char *delim0, *delim1;
+
+	if (chdir(uwsgi.ns)) {
+		uwsgi_error("chdir()");
+		exit(1);
+	}
+
+	if (strcmp(uwsgi.ns, "/")) {
+		ns_tmp_mountpoint = uwsgi_concat2(uwsgi.ns, "/.uwsgi_ns_tmp_mountpoint");
+		mkdir(ns_tmp_mountpoint, S_IRWXU);
+
+		ns_tmp_mountpoint2 = uwsgi_concat2(ns_tmp_mountpoint, "/.uwsgi_ns_tmp_mountpoint");
+		mkdir(ns_tmp_mountpoint2, S_IRWXU);
+
+		if (mount(uwsgi.ns, ns_tmp_mountpoint, "none", MS_BIND, NULL)) {
+			uwsgi_error("mount()");
+		}
+		if (chdir(ns_tmp_mountpoint)) {
+			uwsgi_error("chdir()");
+		}
+
+		if (pivot_root(".", ns_tmp_mountpoint2)) {
+			uwsgi_error("pivot_root()");
+			exit(1);
+		}
+
+
+
+		if (chdir("/")) {
+			uwsgi_error("chdir()");
+			exit(1);
+		}
+
+	}
+
+	uwsgi_log("remounting /proc\n");
+	if (mount("proc", "/proc", "proc", 0, NULL)) {
+		uwsgi_error("mount()");
+	}
+
+	while (unmounted) {
+
+		unmounted = 0;
+		procmounts = fopen("/proc/self/mounts", "r");
+		while (fgets(line, 1024, procmounts) != NULL) {
+			delim0 = strchr(line, ' ');
+			delim0++;
+			delim1 = strchr(delim0, ' ');
+			*delim1 = 0;
+			if (!strcmp(delim0, "/") || !strcmp(delim0, "/proc"))
+				continue;
+			if (!umount(delim0)) {
+				unmounted++;
+			}
+		}
+		fclose(procmounts);
+	}
+
+	if (rmdir("/.uwsgi_ns_tmp_mountpoint/.uwsgi_ns_tmp_mountpoint")) {
+		uwsgi_error("rmdir()");
+	}
+	if (rmdir("/.uwsgi_ns_tmp_mountpoint")) {
+		uwsgi_error("rmdir()");
+	}
+
+	if (strcmp(uwsgi.ns, "/")) {
+		free(ns_tmp_mountpoint2);
+		free(ns_tmp_mountpoint);
+	}
+
+
+
+}

lib/netlink.c

@@ -0,0 +1,382 @@
+#include "../uwsgi.h"
+
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <net/if.h>
+
+#ifdef CLONE_NEWNET
+
+#define NLMSG_TAIL(nmsg) \
+        ((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
+
+#ifndef VETH_INFO_PEER
+# define VETH_INFO_PEER 1
+#endif
+
+
+struct uwsgi_nl_req {
+	struct nlmsghdr nlmsg;
+	struct ifinfomsg ifinfomsg;
+};
+
+struct uwsgi_nl_ipreq {
+	struct nlmsghdr nlmsg;
+	struct ifaddrmsg ifaddrmsg;
+};
+
+struct uwsgi_nl_rtreq {
+	struct nlmsghdr nlmsg;
+	struct rtmsg rtmsg;
+};
+
+int uwsgi_nl_send(struct nlmsghdr *);
+
+struct nlmsghdr *uwsgi_netlink_alloc() {
+
+	size_t len = NLMSG_ALIGN(8192) + NLMSG_ALIGN(sizeof(struct nlmsghdr *));
+
+	struct nlmsghdr *nlmsg = (struct nlmsghdr *) uwsgi_malloc(len);
+
+	memset(nlmsg, 0, len);
+
+	struct uwsgi_nl_req *unr = (struct uwsgi_nl_req *)nlmsg;
+        unr->ifinfomsg.ifi_family = AF_UNSPEC;
+
+	nlmsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
+	nlmsg->nlmsg_type = RTM_NEWLINK;
+	nlmsg->nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK;
+	
+	return nlmsg;
+}
+
+struct nlmsghdr *uwsgi_netlink_ip_alloc() {
+
+        size_t len = NLMSG_ALIGN(8192) + NLMSG_ALIGN(sizeof(struct nlmsghdr *));
+
+        struct nlmsghdr *nlmsg = (struct nlmsghdr *) uwsgi_malloc(len);
+
+        memset(nlmsg, 0, len);
+
+        struct uwsgi_nl_ipreq *uni = (struct uwsgi_nl_ipreq *)nlmsg;
+        uni->ifaddrmsg.ifa_family = AF_INET;
+        uni->ifaddrmsg.ifa_scope = 0;
+
+        nlmsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
+        nlmsg->nlmsg_type = RTM_NEWADDR;
+        nlmsg->nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK|NLM_F_CREATE|NLM_F_EXCL;
+	
+
+        return nlmsg;
+}
+
+struct nlmsghdr *uwsgi_netlink_rt_alloc() {
+
+        size_t len = NLMSG_ALIGN(8192) + NLMSG_ALIGN(sizeof(struct nlmsghdr *));
+
+        struct nlmsghdr *nlmsg = (struct nlmsghdr *) uwsgi_malloc(len);
+
+        memset(nlmsg, 0, len);
+
+        struct uwsgi_nl_rtreq *unr = (struct uwsgi_nl_rtreq *)nlmsg;
+        unr->rtmsg.rtm_family = AF_INET;
+	unr->rtmsg.rtm_table = RT_TABLE_MAIN;
+	unr->rtmsg.rtm_protocol = RTPROT_STATIC;
+        unr->rtmsg.rtm_scope = RT_SCOPE_UNIVERSE;
+        unr->rtmsg.rtm_type = RTN_UNICAST;
+	
+
+        nlmsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+        nlmsg->nlmsg_type = RTM_NEWROUTE;
+        nlmsg->nlmsg_flags = NLM_F_REQUEST|NLM_F_ACK|NLM_F_CREATE|NLM_F_EXCL;
+
+
+        return nlmsg;
+}
+
+int uwsgi_netlink_rt(char *src, char *dst, int dst_prefix, char *gw) {
+
+	struct nlmsghdr *nlmsg = uwsgi_netlink_rt_alloc();
+        struct rtattr *rta;
+        struct in_addr ia;
+        struct in_addr oa;
+        struct in_addr ga;
+	struct uwsgi_nl_rtreq *unr = (struct uwsgi_nl_rtreq *)nlmsg;
+
+        if (inet_pton(AF_INET, src, &ia) <= 0) {
+                uwsgi_error("inet_pton()");
+                free(nlmsg);
+                return -1;
+        }
+
+        if (inet_pton(AF_INET, dst, &oa) <= 0) {
+                uwsgi_error("inet_pton()");
+                free(nlmsg);
+                return -1;
+        }
+
+        if (inet_pton(AF_INET, gw, &ga) <= 0) {
+                uwsgi_error("inet_pton()");
+                free(nlmsg);
+                return -1;
+        }
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_PREFSRC;
+        rta->rta_len = RTA_LENGTH(4);
+        memcpy(RTA_DATA(rta), &ia.s_addr, 4);
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_DST;
+        rta->rta_len = RTA_LENGTH(4);
+        memcpy(RTA_DATA(rta), &oa.s_addr, 4);
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_GATEWAY;
+        rta->rta_len = RTA_LENGTH(4);
+        memcpy(RTA_DATA(rta), &ga.s_addr, 4);
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+	unr->rtmsg.rtm_src_len = 0; 
+	unr->rtmsg.rtm_dst_len = dst_prefix;
+
+        return uwsgi_nl_send(nlmsg);
+}
+
+int uwsgi_netlink_gw(char *iface, char *ip) {
+
+        struct nlmsghdr *nlmsg = uwsgi_netlink_rt_alloc();
+        struct rtattr *rta;
+        struct in_addr ia;
+	uint32_t zero = 0;
+
+        int index = if_nametoindex(iface);
+        if (!index) return -1;
+
+        if (inet_pton(AF_INET, ip, &ia) <= 0) {
+                uwsgi_error("inet_pton()");
+                free(nlmsg);
+                return -1;
+        }
+
+	
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_GATEWAY;
+        rta->rta_len = RTA_LENGTH(4);
+        memcpy(RTA_DATA(rta), &ia.s_addr, 4);
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_DST;
+        rta->rta_len = RTA_LENGTH(4);
+        memcpy(RTA_DATA(rta), &zero, 4);
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = RTA_OIF;
+        rta->rta_len = RTA_LENGTH(sizeof(int));
+        memcpy(RTA_DATA(rta), &index, sizeof(int));
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        return uwsgi_nl_send(nlmsg);
+}
+
+
+int uwsgi_netlink_ip(char *iface, char *ip, int prefix) {
+
+	struct nlmsghdr *nlmsg = uwsgi_netlink_ip_alloc();
+        struct uwsgi_nl_ipreq *uni = (struct uwsgi_nl_ipreq *)nlmsg;
+        struct rtattr *rta;
+	struct in_addr ia;
+
+        int index = if_nametoindex(iface);
+        if (!index) return -1;
+
+        uni->ifaddrmsg.ifa_index = index;
+        uni->ifaddrmsg.ifa_prefixlen = prefix;
+	
+	if (inet_pton(AF_INET, ip, &ia) <= 0) {
+		uwsgi_error("inet_pton()");
+		free(nlmsg);
+		return -1;
+	}
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = IFA_LOCAL;
+        rta->rta_len = RTA_LENGTH(sizeof(struct in_addr));
+        memcpy(RTA_DATA(rta), &ia, sizeof(struct in_addr));
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        rta = NLMSG_TAIL(nlmsg);
+        rta->rta_type = IFA_ADDRESS;
+        rta->rta_len = RTA_LENGTH(sizeof(struct in_addr));
+        memcpy(RTA_DATA(rta), &ia, sizeof(struct in_addr));
+        nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+        return uwsgi_nl_send(nlmsg);
+}
+
+int uwsgi_netlink_veth_attach(char *veth1, pid_t pid) {
+
+	struct nlmsghdr *nlmsg = uwsgi_netlink_alloc();
+	struct uwsgi_nl_req *unr = (struct uwsgi_nl_req *)nlmsg;
+	struct rtattr *rta;
+
+	int index = if_nametoindex(veth1);
+	if (!index) return -1;
+
+	unr->ifinfomsg.ifi_index = index;
+
+	rta = NLMSG_TAIL(nlmsg);
+	rta->rta_type = IFLA_NET_NS_PID;
+	rta->rta_len = RTA_LENGTH(sizeof(pid_t));
+	memcpy(RTA_DATA(rta), &pid, sizeof(pid_t));
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+	return uwsgi_nl_send(nlmsg);
+	
+}
+
+int uwsgi_netlink_ifup(char *iface) {
+
+        struct nlmsghdr *nlmsg = uwsgi_netlink_alloc();
+        struct uwsgi_nl_req *unr = (struct uwsgi_nl_req *)nlmsg;
+
+        int index = if_nametoindex(iface);
+        if (!index) return -1;
+
+        unr->ifinfomsg.ifi_index = index;
+	unr->ifinfomsg.ifi_change |= IFF_UP;
+	unr->ifinfomsg.ifi_flags |= IFF_UP;	
+        return uwsgi_nl_send(nlmsg);
+
+}
+
+int uwsgi_netlink_del(char *iface) {
+
+        struct nlmsghdr *nlmsg = uwsgi_netlink_alloc();
+        struct uwsgi_nl_req *unr = (struct uwsgi_nl_req *)nlmsg;
+
+        int index = if_nametoindex(iface);
+        if (!index) return -1;
+
+	nlmsg->nlmsg_type = RTM_DELLINK;
+        unr->ifinfomsg.ifi_index = index;
+        return uwsgi_nl_send(nlmsg);
+
+}
+
+
+
+int uwsgi_netlink_veth(char *veth0, char *veth1) {
+
+	struct rtattr *rta, *rta0, *rta1, *rta2;
+	
+	struct nlmsghdr *nlmsg = uwsgi_netlink_alloc();
+
+	nlmsg->nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
+
+	// IFLA_LINKINFO
+	rta0 = NLMSG_TAIL(nlmsg);
+	rta0->rta_type = IFLA_LINKINFO;
+	rta0->rta_len = RTA_LENGTH(0);
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta0->rta_len);
+
+	// IFLA_INFO_KIND
+	rta = NLMSG_TAIL(nlmsg);
+	rta->rta_type = IFLA_INFO_KIND;
+	rta->rta_len = RTA_LENGTH(4);
+	memcpy(RTA_DATA(rta), "veth", 4);
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+	// IFLA_INFO_DATA
+	rta1 = NLMSG_TAIL(nlmsg);
+	rta1->rta_type = IFLA_INFO_DATA;
+	rta1->rta_len = RTA_LENGTH(0);
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta1->rta_len);
+
+	// VETH_INFO_PEER
+	rta2 = NLMSG_TAIL(nlmsg);
+	rta2->rta_type = VETH_INFO_PEER;
+	rta2->rta_len = RTA_LENGTH(0);
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta2->rta_len);
+
+	nlmsg->nlmsg_len += sizeof(struct ifinfomsg);
+
+	// IFLA_IFNAME
+	rta = NLMSG_TAIL(nlmsg);
+	rta->rta_type = IFLA_IFNAME;
+	rta->rta_len = RTA_LENGTH(strlen(veth1));
+	memcpy(RTA_DATA(rta), veth1, strlen(veth1));
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+	rta2->rta_len = (void *)NLMSG_TAIL(nlmsg) - (void *)rta2;
+	rta1->rta_len = (void *)NLMSG_TAIL(nlmsg) - (void *)rta1;
+	rta0->rta_len = (void *)NLMSG_TAIL(nlmsg) - (void *)rta0;
+
+	// IFLA_IFNAME
+	rta = NLMSG_TAIL(nlmsg);
+	rta->rta_type = IFLA_IFNAME;
+	rta->rta_len = RTA_LENGTH(strlen(veth0));
+	memcpy(RTA_DATA(rta), veth0, strlen(veth0));
+	nlmsg->nlmsg_len = NLMSG_ALIGN(nlmsg->nlmsg_len) + RTA_ALIGN(rta->rta_len);
+
+	return uwsgi_nl_send(nlmsg);	
+}
+
+int uwsgi_nl_send(struct nlmsghdr *nlmsg) {
+
+	struct sockaddr_nl nladdr;
+
+	struct iovec iov = {
+                .iov_base = (void*)nlmsg,
+                .iov_len = nlmsg->nlmsg_len,
+        };
+
+	struct msghdr msg = {
+                .msg_name = &nladdr,
+                .msg_namelen = sizeof(nladdr),
+                .msg_iov = &iov,
+                .msg_iovlen = 1,
+        };
+        int ret;	
+	int nlfd;
+
+	memset(&nladdr, 0, sizeof(struct sockaddr_nl));
+        nladdr.nl_family = AF_NETLINK;
+        nladdr.nl_pid = 0;
+        nladdr.nl_groups = 0;
+
+	nlfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+	if (nlfd < 0) {
+		uwsgi_error("socket()");
+		free(nlmsg);
+		return -1;
+	}
+
+	ret = sendmsg(nlfd, &msg, 0);
+	if (ret < 0) {
+		uwsgi_error("sendmsg()");
+		free(nlmsg);
+		close(nlfd);
+		return -1;
+	}
+	ret = recvmsg(nlfd, &msg, 0);
+	if (ret < 0) {
+		uwsgi_error("recvmsg()");
+		free(nlmsg);
+		close(nlfd);
+		return -1;
+	}
+
+	if (nlmsg->nlmsg_type == NLMSG_ERROR) {
+                struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(nlmsg);
+                ret = err->error;
+        }
+
+	free(nlmsg);
+	close(nlfd);
+	return ret;
+}
+#endif

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

lib/sun_fixes.c

@@ -0,0 +1,29 @@
+/* function written by Ben Taylor (found in the qemu-devel list) */
+
+#include "../uwsgi.h"
+
+time_t timegm(struct tm *t) {
+	time_t tl, tb;
+	struct tm *tg;
+
+	tl = mktime (t);
+	if (tl == -1) {
+        	t->tm_hour--;
+        	tl = mktime (t);
+        	if (tl == -1)
+            		return -1; /* can't deal with output from strptime */
+
+        	tl += 3600;
+    	}
+    	tg = gmtime (&tl);
+    	tg->tm_isdst = 0;
+   	tb = mktime (tg);
+    	if (tb == -1) {
+        	tg->tm_hour--;
+        	tb = mktime (tg);
+        	if (tb == -1)
+           		return -1; /* can't deal with output from gmtime */
+        	tb += 3600;
+    	}
+	return (tl - (tb - tl));
+}

lock.c

@@ -134,14 +134,32 @@ void uwsgi_rwunlock(void *lock) { uwsgi_unlock(lock); }
 #define UWSGI_LOCK_SIZE 8
 #define UWSGI_RWLOCK_SIZE 8
 
-void uwsgi_lock_init(void *lock) {}
+void uwsgi_lock_init(void *lock) {
+
+	FILE *tf = tmpfile();
+	int fd;
+
+	if (!tf) {
+		uwsgi_error_open("temp lock file");
+		exit(1);
+	}
+	
+	fd = fileno(tf);
+
+	memcpy(lock, &fd, sizeof(int));
+}
 
 void uwsgi_lock(void *lock) {
-	//if (flock((int) *lock, LOCK_EX)) { uwsgi_error("flock()"); }
+
+	int fd;
+	memcpy(&fd, lock, sizeof(int));
+	if (flock(fd, LOCK_EX)) { uwsgi_error("flock()"); }
 }
 
 void uwsgi_unlock(void *lock) {
-	//if (flock((int) *lock, LOCK_UN)) { uwsgi_error("flock()"); }
+	int fd;
+	memcpy(&fd, lock, sizeof(int));
+	if (flock(fd, LOCK_UN)) { uwsgi_error("flock()"); }
 }
 
 void uwsgi_rwlock_init(void *lock) { uwsgi_lock_init(lock) ;}

logging.c

@@ -1,3 +1,4 @@
+#define _NO_UWSGI_RB
 #include "uwsgi.h"
 
 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
@@ -46,6 +47,8 @@ void log_request(struct wsgi_request *wsgi_req) {
 
 	struct uwsgi_app *wi;
 
+	if (wsgi_req->do_not_log) return ;
+
 	if (wsgi_req->app_id >= 0) {
 		wi = &uwsgi.apps[wsgi_req->app_id];
 		if (wi->requests > 0) {
@@ -168,7 +171,13 @@ void get_memusage() {
 	kvm_t *kv;
 	int cnt;
 
+#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
 	if (kv) {
 #if defined(__FreeBSD__) || defined(__DragonFly__)
 

loop.c

@@ -2,12 +2,16 @@
 
 extern struct uwsgi_server uwsgi;
 
-struct wsgi_request* threaded_current_wsgi_req() { return pthread_getspecific(uwsgi.tur_key); }
-struct wsgi_request* simple_current_wsgi_req() { return uwsgi.wsgi_req; }
+struct wsgi_request *threaded_current_wsgi_req() {
+	return pthread_getspecific(uwsgi.tur_key);
+}
+struct wsgi_request *simple_current_wsgi_req() {
+	return uwsgi.wsgi_req;
+}
 
 
 void uwsgi_register_loop(char *name, void *loop) {
-	
+
 	if (uwsgi.loops_cnt >= MAX_LOOPS) {
 		uwsgi_log("you can define %d loops at max\n", MAX_LOOPS);
 		exit(1);
@@ -21,8 +25,8 @@ void uwsgi_register_loop(char *name, void *loop) {
 void *uwsgi_get_loop(char *name) {
 
 	int i;
-	
-	for(i=0;i<uwsgi.loops_cnt;i++) {
+
+	for (i = 0; i < uwsgi.loops_cnt; i++) {
 		if (!strcmp(name, uwsgi.loops[i].name)) {
 			return uwsgi.loops[i].loop;
 		}
@@ -44,149 +48,194 @@ void *simple_loop(void *arg1) {
 
 	if (uwsgi.threads > 1) {
 
+		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &i);
+		pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &i);
 		pthread_setspecific(uwsgi.tur_key, (void *) wsgi_req);
 
 		if (core_id > 0) {
 			// block all signals on new threads
 			sigfillset(&smask);
 			pthread_sigmask(SIG_BLOCK, &smask, NULL);
-			for(i=0;i<0xFF;i++) {
+			for (i = 0; i < 0xFF; i++) {
 				if (uwsgi.p[i]->init_thread) {
 					uwsgi.p[i]->init_thread(core_id);
 				}
 			}
-			/*
-			   pts = PyThreadState_New(uwsgi.main_thread->interp);
-			   pthread_setspecific(uwsgi.ut_save_key, (void *) pts);
-			   */
 		}
 	}
 #endif
 
+	// initialize the main event queue to monitor sockets
+	int main_queue = event_queue_init();
+
+	uwsgi_add_sockets_to_queue(main_queue);
+
+	if (uwsgi.signal_socket > -1) {
+		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);
 
-		UWSGI_CLEAR_STATUS;
-
-
-		wsgi_req_setup(wsgi_req, core_id);
-
-		if (wsgi_req_accept(wsgi_req)) {
+		if (wsgi_req_accept(main_queue, wsgi_req)) {
 			continue;
 		}
 
 		if (wsgi_req_recv(wsgi_req)) {
+			uwsgi_destroy_request(wsgi_req);
 			continue;
 		}
 
 		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;
 }
 
-#ifdef UWSGI_ASYNC
-void complex_loop() {
-	int current_async_timeout = 0;
-	int i, j;
-	int interesting_fd;
+#ifdef UWSGI_ZEROMQ
+void *zeromq_loop(void *arg1) {
+	sigset_t smask;
+	int i;
+
+	long core_id = (long) arg1;
+
+	struct wsgi_request *wsgi_req = uwsgi.wsgi_requests[core_id];
+	uwsgi.zeromq_recv_flag = 0;
+	zmq_pollitem_t zmq_poll_items[3];
+	char uwsgi_signal;
+
+	if (uwsgi.threads > 1) {
+
+		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &i);
+		pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &i);
+		pthread_setspecific(uwsgi.tur_key, (void *) wsgi_req);
+
+		if (core_id > 0) {
+			// block all signals on new threads
+			sigfillset(&smask);
+			pthread_sigmask(SIG_BLOCK, &smask, NULL);
+			for (i = 0; i < 0xFF; i++) {
+				if (uwsgi.p[i]->init_thread) {
+					uwsgi.p[i]->init_thread(core_id);
+				}
+			}
+
+
+			void *tmp_zmq_pull = zmq_socket(uwsgi.zmq_context, ZMQ_PULL);
+			if (tmp_zmq_pull == NULL) {
+				uwsgi_error("zmq_socket()");
+				exit(1);
+			}
+			if (zmq_connect(tmp_zmq_pull, uwsgi.zmq_receiver) < 0) {
+				uwsgi_error("zmq_connect()");
+				exit(1);
+			}
+
+			pthread_setspecific(uwsgi.zmq_pull, tmp_zmq_pull);
+		}
+
+	}
+
+
+	if (uwsgi.signal_socket > -1) {
+		zmq_poll_items[0].socket = pthread_getspecific(uwsgi.zmq_pull);
+		zmq_poll_items[0].fd = -1;
+		zmq_poll_items[0].events = ZMQ_POLLIN;
+
+		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;
+	}
 
-	struct wsgi_request *wsgi_req;
 
 	while (uwsgi.workers[uwsgi.mywid].manage_next_request) {
 
-		current_async_timeout = async_get_timeout();
+		wsgi_req_setup(wsgi_req, core_id, NULL);
 
-		uwsgi.async_nevents = event_queue_wait_multi(uwsgi.async_queue, current_async_timeout, uwsgi.async_events, 64);
-		async_expire_timeouts();
-
-		if (uwsgi.async_nevents < 0) {
-			continue;
-		}
+		uwsgi.edge_triggered = 1;
+		wsgi_req->socket = uwsgi.zmq_socket;
 
 
-		
-		for(i=0; i<uwsgi.async_nevents;i++) {
+		if (uwsgi.signal_socket > -1) {
+			if (zmq_poll(zmq_poll_items, 3, -1) < 0) {
+				uwsgi_error("zmq_poll()");
+				continue;
+			}
 
-			interesting_fd = event_queue_interesting_fd(uwsgi.async_events, i);
+			if (zmq_poll_items[1].revents & ZMQ_POLLIN) {
+                		if (read(uwsgi.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 ( interesting_fd == uwsgi.sockets[0].fd) {
-
-				uwsgi.wsgi_req = find_first_available_wsgi_req();
-				if (uwsgi.wsgi_req == NULL) {
-					// async system is full !!!
-					goto cycle;
-				}
-
-				wsgi_req_setup(uwsgi.wsgi_req, uwsgi.wsgi_req->async_id );
-
-                                if (wsgi_req_simple_accept(uwsgi.wsgi_req, interesting_fd)) {
-                                        continue;
-                                }
-
-// on linux we do not need to reset the socket to blocking state
-#ifndef __linux__
-                                if (uwsgi.numproc > 1) {
-                                        /* re-set blocking socket */
-                                        if (fcntl(uwsgi.wsgi_req->poll.fd, F_SETFL, uwsgi.sockets[0].arg) < 0) {
-                                                uwsgi_error("fcntl()");
-						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 (wsgi_req_recv(uwsgi.wsgi_req)) {
-					continue;
-				}
+			
 
-				if (uwsgi.wsgi_req->async_status == UWSGI_OK) {
-					goto reqclear;
-				}
-
-			}
-			else if (  interesting_fd == uwsgi.sockets_poll[uwsgi.sockets_cnt].fd) {
-				// wake up cores waiting for signal
-				char byte;
-				if (read(uwsgi.sockets_poll[uwsgi.sockets_cnt].fd, &byte, 1) == 1) {
-				}
-				else {
-					uwsgi_error("read()");
-				}
-				for(j=0;j<uwsgi.async_current_max;j++) {
-                			wsgi_req = uwsgi.wsgi_requests[j] ;
-                			if (wsgi_req->sigwait) {
-						wsgi_req->signal_received = byte;
-						wsgi_req->sigwait = 0;
-					}
-				}
-			}
-			else {
-				uwsgi.wsgi_req = find_wsgi_req_by_fd(interesting_fd);
-				if (uwsgi.wsgi_req) {
-					uwsgi.wsgi_req->async_status = UWSGI_AGAIN;
-					uwsgi.wsgi_req->async_waiting_fd = -1;
-					uwsgi.wsgi_req->async_waiting_fd_monitored = 0;
-					uwsgi.wsgi_req->async_timeout = 0;
-				}
-
-				event_queue_del_fd(uwsgi.async_queue, interesting_fd);
+			if (zmq_poll_items[0].revents & ZMQ_POLLIN) {
+				wsgi_req->poll.fd = wsgi_req->socket->proto_accept(wsgi_req, uwsgi.zmq_socket->fd);
 			}
 		}
+		else {
+			wsgi_req->poll.fd = wsgi_req->socket->proto_accept(wsgi_req, uwsgi.zmq_socket->fd);
+		}
 
-cycle:
-
-		uwsgi.wsgi_req = async_loop();
-
-		if (uwsgi.wsgi_req == NULL)
-			continue;
-		uwsgi.wsgi_req->async_status = UWSGI_OK;
-
-reqclear:
-		uwsgi_close_request(uwsgi.wsgi_req);
+		if (wsgi_req->poll.fd >= 0) {
+			wsgi_req_recv(wsgi_req);
+		}
 
+		uwsgi_close_request(wsgi_req);
 	}
+
+
+        // end of the loop
+        return NULL;
 }
 #endif

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;
+	}
+
+
+}

mongrel2-uwsgi.conf

@@ -0,0 +1,23 @@
+main = Server(
+    uuid="f400bf85-4538-4f7a-8908-67e313d515c2",
+    access_log="/logs/access.log",
+    error_log="/logs/error.log",
+    chroot="./",
+    default_host="192.168.173.18",
+    name="test",
+    pid_file="/run/mongrel2.pid",
+    port=6767,
+    hosts = [
+        Host(name="192.168.173.18", routes={
+            '/': Handler(send_spec='tcp://192.168.173.18:9999',
+                    send_ident='54c6755b-9628-40a4-9a2d-cc82a816345e', 
+                    recv_spec='tcp://192.168.173.18:9998', recv_ident='')
+        })
+    ]
+)
+
+settings = {'upload.temp_store':'tmp/mongrel2.upload.XXXXXX'}
+servers = [main]
+
+
+uwsgi = { 'socket':':3031', 'master':'true'}

multi.ini

@@ -1,13 +1,27 @@
 [uwsgi]
+
+; socket 0
 socket = :3033
+; socket 1
 socket = :3034
-vacuum = true
+; socket 2
 socket = pippo1.sock
+; socket 3
 socket = pippo2.sock
+; socket 4
 socket = 127.0.0.1:1717
+
+map-socket = 0:1,2,3,4
+map-socket = 1:4
+map-socket = 2:10
+map-socket = 3:5,6,9
+map-socket = 4:7,8,9
+
+
+vacuum = true
 memory-report = true
 master = true
 processes = 10
-mount = /app1=werkzeug.testapp:test_app
-mount = /app2=config:/Users/roberta/uwsgi/my.ini
-mount = /app3=pinaxsite/deploy/pinax.wsgi
+;mount = /app1=werkzeug.testapp:test_app
+;mount = /app2=config:/Users/roberta/uwsgi/my.ini
+;mount = /app3=pinaxsite/deploy/pinax.wsgi

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

@@ -0,0 +1,72 @@
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+
+
+void uwsgi_systemd_notify(char *message) {
+
+	struct msghdr *msghdr = (struct msghdr *) uwsgi.notification_object;
+	struct iovec *iovec = msghdr->msg_iov;
+
+	iovec[0].iov_base = "STATUS=";
+	iovec[0].iov_len = 7;
+
+	iovec[1].iov_base = message;
+	iovec[1].iov_len = strlen(message);
+
+	iovec[2].iov_base = "\n";
+        iovec[2].iov_len = 1;
+
+	msghdr->msg_iovlen = 3;
+
+	sendmsg(uwsgi.notification_fd, msghdr, 0);
+}
+
+void uwsgi_systemd_notify_ready(void) {
+
+	struct msghdr *msghdr = (struct msghdr *) uwsgi.notification_object;
+        struct iovec *iovec = msghdr->msg_iov;
+
+        iovec[0].iov_base = "STATUS=uWSGI is ready\nREADY=1\n";
+        iovec[0].iov_len = 30;
+
+	msghdr->msg_iovlen = 1;
+
+	sendmsg(uwsgi.notification_fd, msghdr, 0);
+	
+}
+
+
+void uwsgi_systemd_init(char *systemd_socket) {
+
+	struct sockaddr_un *sd_sun;
+	struct msghdr *msghdr;
+
+	uwsgi.notification_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+	if (uwsgi.notification_fd < 0) {
+		uwsgi_error("socket()");
+		return;
+	}
+
+	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));
+
+	msghdr->msg_iov = uwsgi_malloc(sizeof(struct iovec)*3);
+	memset(msghdr->msg_iov, 0, sizeof(struct iovec)*3);
+
+	msghdr->msg_name = sd_sun;
+	msghdr->msg_namelen = sizeof(struct sockaddr_un);
+
+	uwsgi.notification_object = msghdr;
+
+	uwsgi.notify = uwsgi_systemd_notify;
+	uwsgi.notify_ready = uwsgi_systemd_notify_ready;
+	
+}

plugins.c

@@ -2,63 +2,149 @@
 
 extern struct uwsgi_server uwsgi;
 
-void embed_plugins() {
-
-#ifdef UWSGI_EMBED_PLUGIN_PSGI
-	if (uwsgi.plugin_arg_psgi)
-		uwsgi_load_plugin(5, "psgi_plugin.so", uwsgi.plugin_arg_psgi, 0);
-#endif
-
-#ifdef UWSGI_EMBED_PLUGIN_LUA
-	if (uwsgi.plugin_arg_lua)
-		uwsgi_load_plugin(6, "lua_plugin.so", uwsgi.plugin_arg_lua, 0);
-#endif
-
-#ifdef UWSGI_EMBED_PLUGIN_RACK
-	if (uwsgi.plugin_arg_rack)
-		uwsgi_load_plugin(7, "rack_plugin.so", uwsgi.plugin_arg_rack, 0);
-#endif
-
-}
-
-int uwsgi_load_plugin(int modifier, char *plugin, char *pargs, int absolute) {
+void *uwsgi_load_plugin(int modifier, char *plugin, char *has_option, int absolute) {
 
 	void *plugin_handle;
 
 	char *plugin_name;
 	char *plugin_entry_symbol;
 	struct uwsgi_plugin *up;
+	char linkpath_buf[1024], linkpath[1024];
+	int linkpath_size;
+	int i;
 
-	if (absolute) {
-		plugin_name = malloc(strlen(plugin) + 1);
-		memcpy(plugin_name, plugin, strlen(plugin) + 1);
+	char *colon = strchr(plugin, ':');
+	if (colon) {
+		colon[0] = 0;
+	}
+
+check:
+	for (i = 0; i < 0xFF; i++) {
+		if (uwsgi.p[i]->name) {
+			if (!strcmp(plugin, uwsgi.p[i]->name)) {
+#ifdef UWSGI_DEBUG
+				uwsgi_log("%s plugin already available\n", plugin);
+#endif
+				return NULL;
+			}	
+		}
+		if (uwsgi.p[i]->alias) {
+			if (!strcmp(plugin, uwsgi.p[i]->alias)) {
+#ifdef UWSGI_DEBUG
+				uwsgi_log("%s plugin already available\n", plugin);
+#endif
+				return NULL;
+			}	
+		}
+	}
+
+	for(i=0;i<uwsgi.gp_cnt;i++) {
+
+		if (uwsgi.gp[i]->name) {
+                        if (!strcmp(plugin, uwsgi.gp[i]->name)) {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("%s plugin already available\n", plugin);
+#endif
+                                return NULL;
+                        }       
+                }
+                if (uwsgi.gp[i]->alias) {
+                        if (!strcmp(plugin, uwsgi.gp[i]->alias)) {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("%s plugin already available\n", plugin);
+#endif
+                                return NULL;
+                        }
+                }
+        }
+
+	if (colon) {
+		plugin = colon+1;
+		colon[0] = ':';
+		colon = NULL;
+		goto check;
+	}
+
+	if (absolute == 1) {
+		plugin_name = uwsgi_concat2(plugin, "");
+		// need to fix this... postpone until needed
+		plugin_entry_symbol = uwsgi_concat2n(plugin, strlen(plugin)-3 ,"", 0);
 	}	
+	else if (absolute == 2) {
+		plugin_name = uwsgi_concat3(UWSGI_PLUGIN_DIR, "/", plugin);
+		plugin_entry_symbol = uwsgi_concat2n(plugin, strlen(plugin)-3 ,"", 0);
+	}
 	else {
 		plugin_name = uwsgi_concat4(UWSGI_PLUGIN_DIR, "/", plugin, "_plugin.so");
+		plugin_entry_symbol = uwsgi_concat2(plugin, "_plugin");
 	}
 	plugin_handle = dlopen(plugin_name, RTLD_NOW | RTLD_GLOBAL);
-	free(plugin_name);
 
         if (!plugin_handle) {
                 uwsgi_log( "%s\n", dlerror());
         }
         else {
-		plugin_entry_symbol = uwsgi_concat2(plugin, "_plugin");
                 up = dlsym(plugin_handle, plugin_entry_symbol);
+		if (!up) {
+			// is it a link ?
+			memset(linkpath_buf, 0, 1024);
+			memset(linkpath, 0, 1024);
+			if ((linkpath_size = readlink(plugin_name, linkpath_buf, 1023)) > 0) {
+				do {
+					linkpath_buf[linkpath_size] = '\0';
+					strcpy(linkpath, linkpath_buf);
+				} while ((linkpath_size = readlink(linkpath, linkpath_buf, 1023)) > 0);
+				uwsgi_log("%s\n", linkpath);
+				free(plugin_entry_symbol);
+				up = dlsym(plugin_handle, plugin_entry_symbol);
+				char *slash = uwsgi_get_last_char(linkpath, '/');
+				if (!slash) {
+					slash = linkpath;
+				}
+				else {
+					slash++;
+				}
+				plugin_entry_symbol = uwsgi_concat2n(slash, strlen(slash)-3, "",0);
+				up = dlsym(plugin_handle, plugin_entry_symbol);
+			}
+		}
                 if (up) {
+			if (has_option) {
+				struct option *lopt = up->options, *aopt;
+				int found = 0;
+				while ((aopt = lopt)) {
+                			if (!aopt->name)
+                        			break;
+					if (!strcmp(has_option, aopt->name)) {
+						found = 1;
+						break;
+					}	
+                			lopt++;
+				}
+				if (!found) {
+					if (dlclose(plugin_handle)) {
+						uwsgi_error("dlclose()");
+					}
+					free(plugin_name);
+					free(plugin_entry_symbol);
+					return NULL;
+				}
+				
+			}
 			if (modifier != -1) {
 				fill_plugin_table(modifier, up);			
 			}
 			else {
 				fill_plugin_table(up->modifier1, up);			
 			}
-			return 1;
+			free(plugin_name);
+			free(plugin_entry_symbol);
+			return plugin_handle;
                 }
                 uwsgi_log( "%s\n", dlerror());
         }
 
-	return 0;
+	free(plugin_name);
 
-
-	return -1;
+	return NULL;
 }

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

@@ -0,0 +1,104 @@
+#include "../../uwsgi.h"
+
+void cache_command(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
+
+        struct wsgi_request *wsgi_req = (struct wsgi_request *) data;
+        uint64_t tmp_vallen = 0;
+
+        if (vallen > 0) {
+                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);
+                        }
+
+                }
+                else if (!uwsgi_strncmp(key, keylen, "get", 3)) {
+                        val = uwsgi_cache_get(val, vallen, &tmp_vallen);
+                        if (val && vallen > 0) {
+                                wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, val, tmp_vallen);
+                        }
+                        else {
+                                wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, "HTTP/1.0 404 Not Found\r\n\r\n<h1>Not Found</h1>", 44);
+                        }
+                }
+        }
+}
+
+
+int uwsgi_cache_request(struct wsgi_request *wsgi_req) {
+
+        uint64_t vallen = 0;
+        char *value;
+        char *argv[3];
+        uint8_t argc = 0;
+
+        switch(wsgi_req->uh.modifier2) {
+                case 0:
+                        // get
+                        if (wsgi_req->uh.pktsize > 0) {
+                                value = uwsgi_cache_get(wsgi_req->buffer, wsgi_req->uh.pktsize, &vallen);
+                                if (value && vallen > 0) {
+                                        wsgi_req->uh.pktsize = vallen;
+                                        wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, (char *)&wsgi_req->uh, 4);
+                                        wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, value, vallen);
+                                }
+                        }
+                        break;
+                case 1:
+                        // set
+                        if (wsgi_req->uh.pktsize > 0) {
+                                argc = 3;
+                                if (!uwsgi_parse_array(wsgi_req->buffer, wsgi_req->uh.pktsize, argv, &argc)) {
+                                        if (argc > 1) {
+                                                uwsgi_cache_set(argv[0], strlen(argv[0]), argv[1], strlen(argv[1]), 0, 0);
+                                        }
+                                }
+                        }
+                        break;
+                case 2:
+                        // del
+                        if (wsgi_req->uh.pktsize > 0) {
+                                uwsgi_cache_del(wsgi_req->buffer, wsgi_req->uh.pktsize);
+                        }
+                        break;
+                case 3:
+                case 4:
+                        // dict
+                        if (wsgi_req->uh.pktsize > 0) {
+                                uwsgi_hooked_parse(wsgi_req->buffer, wsgi_req->uh.pktsize, cache_command, (void *) wsgi_req);
+                        }
+                        break;
+                case 5:
+                        // get (uwsgi + stream)
+                        if (wsgi_req->uh.pktsize > 0) {
+                                value = uwsgi_cache_get(wsgi_req->buffer, wsgi_req->uh.pktsize, &vallen);
+                                if (value && vallen > 0) {
+                                        wsgi_req->uh.pktsize = 0;
+                                        wsgi_req->uh.modifier2 = 1;
+                                        wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, (char *)&wsgi_req->uh, 4);
+                                        wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, value, vallen);
+                                }
+                                else {
+                                        wsgi_req->uh.pktsize = 0;
+                                        wsgi_req->uh.modifier2 = 0;
+                                        wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, (char *)&wsgi_req->uh, 4);
+                                }
+                        }
+                        break;
+        }
+
+        return 0;
+}
+
+struct uwsgi_plugin cache_plugin = {
+
+        .name = "cache",
+        .modifier1 = 111,
+        .request = uwsgi_cache_request,
+
+};
+

plugins/cache/uwsgiplugin.py

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

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 = write(wsgi_req->poll.fd, 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/erlang/erlang.c

@@ -247,6 +247,7 @@ void erlang_loop() {
 	int fd;
 
 	int eversion;
+	int i;
 
 	ei_x_buff x, xr;
 
@@ -291,13 +292,31 @@ void erlang_loop() {
 					
 					x.index = 0;
 					ei_decode_version(x.buff, &x.index, &eversion);
+#ifdef UWSGI_DEBUG
 					uwsgi_log("eversion: %d\n", eversion);
+#endif
 
 					if (!strcmp(em.toname, "rex")) {
 						uwsgi_erlang_rpc(fd, &em.from, &x);
 					}
 					else {
-						dump_eterm(&x);
+						int uep = -1;
+						for(i=0;i<uerl.uep_cnt;i++) {
+							if (!strcmp(uerl.uep[i].name, em.toname)) {
+								uep = i;
+								break;
+							}
+						}
+
+						if (uep > -1) {
+							if (uerl.uep[uep].plugin) {
+								uerl.uep[uep].plugin( uerl.uep[uep].func, &x );
+							}
+						}
+						else {
+							uwsgi_log("!!! unregistered erlang process requested, dumping it !!!\n");
+							dump_eterm(&x);
+						}
 					}
 					
 					
@@ -428,6 +447,7 @@ int erlang_opt(int i, char *optarg) {
 
 struct uwsgi_plugin erlang_plugin = {
 
+	.name = "erlang",
         .options = erlang_options,
         .manage_opt = erlang_opt,
         .init = erlang_init,

plugins/erlang/erlang.h

@@ -1,9 +1,19 @@
 #include <ei.h>
 
+#define MAX_UWSGI_ERLANG_PROCESSES 64
+
 #define LONG_ARGS_ERLANG                17012
 #define LONG_ARGS_ERLANG_COOKIE         17013
 
 
+
+struct uwsgi_erlang_process {
+	
+	char name[0xff];
+	void (*plugin)(void *, ei_x_buff *);
+	void *func;
+};
+
 struct uwsgi_erlang {
 
         ei_cnode cnode;
@@ -13,6 +23,8 @@ struct uwsgi_erlang {
         int fd;
 
 	void *lock;
+
+	struct uwsgi_erlang_process uep[MAX_UWSGI_ERLANG_PROCESSES];
+	int uep_cnt;
 };
 
-

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 += write(wsgi_req->poll.fd, 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

@@ -12,10 +12,13 @@
 
 #include "../../uwsgi.h"
 
-#define LONG_ARGS_FASTROUTER			150001
-#define LONG_ARGS_FASTROUTER_EVENTS		150002
-#define LONG_ARGS_FASTROUTER_USE_PATTERN	150003
-#define LONG_ARGS_FASTROUTER_USE_BASE		150004
+#define LONG_ARGS_FASTROUTER				150001
+#define LONG_ARGS_FASTROUTER_EVENTS			150002
+#define LONG_ARGS_FASTROUTER_USE_PATTERN		150003
+#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
@@ -23,29 +26,97 @@
 #define FASTROUTER_STATUS_RECV_VARS 3
 #define FASTROUTER_STATUS_RESPONSE 4
 
+#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;
+
+        int subscription_slot;
+
+        char *pattern;
+        int pattern_len;
+
+        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},
 	{"fastrouter-use-pattern", required_argument, 0, LONG_ARGS_FASTROUTER_USE_PATTERN},
 	{"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},	
 };
 
 extern struct uwsgi_server uwsgi;
 
+void fastrouter_manage_subscription(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
+	
+	struct uwsgi_subscribe_req *usr = (struct uwsgi_subscribe_req *) data;
+	
+	if (!uwsgi_strncmp("key", 3, key, keylen)) {
+		usr->key = val;
+		usr->keylen = vallen;
+	}
+	else if (!uwsgi_strncmp("address", 7, key, keylen)) {
+		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 {
 
 	int fd;
@@ -59,12 +130,60 @@ struct fastrouter_session {
 	char *hostname;
 	uint16_t hostname_len;
 
+	int has_key;
+
 	char *instance_address;
 	uint64_t instance_address_len;
 
+	struct uwsgi_subscriber_name *un;
 	int pass_fd;
+
+	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) {
+
+	close(fr_session->fd);
+	fr_table[fr_session->fd] = NULL;
+	if (fr_session->instance_fd != -1) {
+		if (ufr.subscription_server && (fr_session->instance_failed || fr_session->status == FASTROUTER_STATUS_CONNECTING)) {
+			uwsgi_log("marking %.*s as failed\n", (int) fr_session->instance_address_len,fr_session->instance_address);
+			fr_session->un->len = 0;
+		}
+		close(fr_session->instance_fd);
+		fr_table[fr_session->instance_fd] = NULL;
+	}
+	del_timeout(fr_session); 
+	free(fr_session);
+}
+
+static struct uwsgi_rb_timer *reset_timeout(struct fastrouter_session *fr_session) {
+	del_timeout(fr_session);
+	return add_timeout(fr_session);
+}
+
+static void expire_timeouts(struct fastrouter_session **fr_table) {
+
+	time_t current = time(NULL);
+	struct uwsgi_rb_timer *urbt;
+
+	for(;;) {
+		urbt = uwsgi_min_rb_timer(ufr.timeouts);
+		if (urbt == NULL) return;
+
+		if (urbt->key <= current) {
+			close_session(fr_table, (struct fastrouter_session *)urbt->data);
+			uwsgi_log("timeout !!!\n");
+			continue;
+		}
+
+		break;
+	}
+}
+
 void fr_get_hostname(char *key, uint16_t keylen, char *val, uint16_t vallen, void *data) {
 
 	struct fastrouter_session *fr_session = (struct fastrouter_session *) data;
@@ -76,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;
@@ -91,18 +217,26 @@ struct fastrouter_session *alloc_fr_session() {
 void fastrouter_loop() {
 
 	int fr_queue;
-	int fr_server;
 	int nevents;
 	int interesting_fd;
 	int new_connection;
 	ssize_t len;
 	int i;
 
+	time_t delta;
+	char bbuf[UMAX16];
+
+	char *tcp_port;
+
 	char *tmp_socket_name;
 	int tmp_socket_name_len;
 
+	struct uwsgi_subscribe_req usr;
+
 	char *magic_table[0xff];
 
+	struct uwsgi_rb_timer *min_timeout;
+
 	void *events;
 	struct msghdr msg;
 	union {
@@ -123,25 +257,77 @@ void fastrouter_loop() {
 	int soopt;
         socklen_t solen = sizeof(int);
 
+	int ufr_subserver = -1;
+
 	for(i=0;i<2048;i++) {
 		fr_table[i] = NULL;
 	}
 
-	fr_server = bind_to_tcp(ufr.socket_name, uwsgi.listen_queue, ufr.socket_name);
-
 	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_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;
+	}
+
+
 	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);
+		if (!ufr.subscription_slot) ufr.subscription_slot = 30;
+		ufr.subscription_dict = uwsgi_dict_create(ufr.subscription_slot, 0);
+	}
 
 	if (ufr.pattern) {
 		init_magic_table(magic_table);
 	}
 
+	ufr.timeouts = uwsgi_init_rb_timer();
+	if (!ufr.socket_timeout) ufr.socket_timeout = 30;
+
 	for (;;) {
 
-		nevents = event_queue_wait_multi(fr_queue, -1, events, ufr.nevents);
+		min_timeout = uwsgi_min_rb_timer(ufr.timeouts);
+		if (min_timeout == NULL ) {
+			delta = -1;
+		}
+		else {
+			delta = min_timeout->key - time(NULL);
+			if (delta <= 0) {
+				expire_timeouts(fr_table);
+				delta = 0;
+			}
+		}
+
+		nevents = event_queue_wait_multi(fr_queue, delta, events, ufr.nevents);
+
+		if (nevents == 0) {
+			expire_timeouts(fr_table);
+		}
 
 		for (i=0;i<nevents;i++) {
 
@@ -149,23 +335,49 @@ 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]->timeout = add_timeout(fr_table[new_connection]);
+
+					event_queue_add_fd_read(fr_queue, new_connection);
+					taken = 1;
+					break;
 				}
-
-				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_address_len = 0;
-
-				event_queue_add_fd_read(fr_queue, new_connection);
 				
+				uwsgi_sock = uwsgi_sock->next;
 			}	
+
+			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);
+#endif
+				if (len > 0) {
+					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
+					uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
+					uwsgi_add_subscriber(ufr.subscription_dict, &usr);
+				}
+			}
 			else {
 				fr_session = fr_table[interesting_fd];
 
@@ -173,25 +385,19 @@ void fastrouter_loop() {
 				if (fr_session == NULL) continue;
 
 				if (event_queue_interesting_fd_has_error(events, i)) {
-					close(fr_session->fd);
-                                        fr_table[fr_session->fd] = NULL;
-                                        if (fr_session->instance_fd != -1) {
-                                        	close(fr_session->instance_fd);
-                                                fr_table[fr_session->instance_fd] = NULL;
-                                        }
-                                        free(fr_session);
+					close_session(fr_table, fr_session);
 					continue;
 				}
 
+				fr_session->timeout = reset_timeout(fr_session);
+
 				switch(fr_session->status) {
 
 					case FASTROUTER_STATUS_RECV_HDR:
 						len = recv(fr_session->fd, (char *)(&fr_session->uh) + fr_session->h_pos, 4-fr_session->h_pos, 0);
 						if (len <= 0) {
 							uwsgi_error("recv()");
-							close(fr_session->fd);
-							fr_table[fr_session->fd] = NULL;
-							free(fr_session);
+							close_session(fr_table, fr_session);
 							break;
 						}
 						fr_session->h_pos += len;
@@ -208,28 +414,24 @@ void fastrouter_loop() {
                                                 len = recv(fr_session->fd, fr_session->buffer + fr_session->pos, fr_session->uh.pktsize - fr_session->pos, 0);
                                                 if (len <= 0) {
                                                         uwsgi_error("recv()");
-							close(fr_session->fd);
-							fr_table[fr_session->fd] = NULL;
-							free(fr_session);
+							close_session(fr_table, fr_session);
                                                         break;
                                                 }
                                                 fr_session->pos += len;
                                                 if (fr_session->pos == fr_session->uh.pktsize) {
 							if (uwsgi_hooked_parse(fr_session->buffer, fr_session->uh.pktsize, fr_get_hostname, (void *) fr_session)) {
-								close(fr_session->fd);
-								fr_table[fr_session->fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
 							if (fr_session->hostname_len == 0) {
-								close(fr_session->fd);
-								fr_table[fr_session->fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	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);
 							}
@@ -240,6 +442,14 @@ void fastrouter_loop() {
 								fr_session->instance_address_len = tmp_socket_name_len;
 								fr_session->instance_address = tmp_socket_name;
 							}
+							else if (ufr.subscription_server) {
+								fr_session->un = uwsgi_get_subscriber(ufr.subscription_dict, fr_session->hostname, fr_session->hostname_len);
+								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) {
 								tmp_socket_name = uwsgi_concat2nn(ufr.base, ufr.base_len, fr_session->hostname, fr_session->hostname_len, &tmp_socket_name_len);
 								fr_session->instance_address_len = tmp_socket_name_len;
@@ -248,9 +458,7 @@ void fastrouter_loop() {
 
 							// no address found
 							if (!fr_session->instance_address_len) {
-								close(fr_session->fd);
-								fr_table[fr_session->fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
@@ -262,9 +470,11 @@ void fastrouter_loop() {
 							if (tmp_socket_name) free(tmp_socket_name);
 
 							if (fr_session->instance_fd < 0) {
-								close(fr_session->fd);
-								fr_table[fr_session->fd] = NULL;
-								free(fr_session);
+								if (ufr.subscription_server) {
+	                                                        	uwsgi_log("marking %.*s as failed\n", (int) fr_session->instance_address_len,fr_session->instance_address);
+	                                                        	fr_session->un->len = 0;
+	                                                        }
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
@@ -283,31 +493,31 @@ void fastrouter_loop() {
 
 							if (getsockopt(fr_session->instance_fd, SOL_SOCKET, SO_ERROR, (void *) (&soopt), &solen) < 0) {
                                                 		uwsgi_error("getsockopt()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								fr_session->instance_failed = 1;
+								close_session(fr_table, fr_session);
                                                         	break;
                                         		}
 
 							if (soopt) {
 								uwsgi_log("unable to connect() to uwsgi instance: %s\n", strerror(soopt));
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								fr_session->instance_failed = 1;
+								close_session(fr_table, fr_session);
                                                         	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;
@@ -327,26 +537,17 @@ void fastrouter_loop() {
 									uwsgi_error("sendmsg()");
 								}
 
-								close(fr_session->fd);
-                                                                close(fr_session->instance_fd);
-                                                                fr_table[fr_session->fd] = NULL;
-                                                                fr_table[fr_session->instance_fd] = NULL;
-                                                                free(fr_session);
+								close_session(fr_table, fr_session);	
                                                                 break;
 							}
 
 							if (writev(fr_session->instance_fd, iov, 2) < 0) {
 								uwsgi_error("writev()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
-							event_queue_del_fd(fr_queue, fr_session->instance_fd);
-							event_queue_add_fd_read(fr_queue, fr_session->instance_fd);
+							event_queue_fd_write_to_read(fr_queue, fr_session->instance_fd);
 							fr_session->status = FASTROUTER_STATUS_RESPONSE;
 						}
 
@@ -359,11 +560,7 @@ void fastrouter_loop() {
 							len = recv(fr_session->instance_fd, fr_session->buffer, 0xffff, 0);
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("recv()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
@@ -371,13 +568,13 @@ void fastrouter_loop() {
 							
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("send()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								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) {
@@ -386,11 +583,7 @@ void fastrouter_loop() {
 							len = recv(fr_session->fd, fr_session->buffer, 0xffff, 0);
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("recv()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 
@@ -399,11 +592,7 @@ void fastrouter_loop() {
 							
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("send()");
-								close(fr_session->fd);
-								close(fr_session->instance_fd);
-								fr_table[fr_session->fd] = NULL;
-								fr_table[fr_session->instance_fd] = NULL;
-								free(fr_session);
+								close_session(fr_table, fr_session);
                                                         	break;
 							}
 						}
@@ -415,13 +604,7 @@ void fastrouter_loop() {
 					// fallback to destroy !!!
 					default:
 						uwsgi_log("default action\n");
-						close(fr_session->fd);
-						fr_table[fr_session->fd] = NULL;
-						if (fr_session->instance_fd != -1) {
-							close(fr_session->instance_fd);
-							fr_table[fr_session->instance_fd] = NULL;
-						}
-						free(fr_session);
+						close_session(fr_table, fr_session);
 						break;
 					
 				}
@@ -433,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");
@@ -455,7 +638,10 @@ 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;
 			return 1;
 		case LONG_ARGS_FASTROUTER_EVENTS:
 			ufr.nevents = atoi(optarg);
@@ -470,6 +656,12 @@ int fastrouter_opt(int i, char *optarg) {
 			// optimization
 			ufr.base_len = strlen(ufr.base);
 			return 1;
+		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;
 }
@@ -477,6 +669,7 @@ int fastrouter_opt(int i, char *optarg) {
 
 struct uwsgi_plugin fastrouter_plugin = {
 
+	.name = "fastrouter",
         .options = fastrouter_options,
         .manage_opt = fastrouter_opt,
         .init = fastrouter_init,

plugins/fiber/fiber.c

@@ -0,0 +1,85 @@
+#include "../rack/uwsgi_rack.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_rack ur;
+
+struct ufib {
+	VALUE *fib;
+} ufiber;
+
+struct option fiber_options[] = {
+	{ 0, 0, 0, 0 }
+};
+
+VALUE uwsgi_fiber_request() {
+
+	uwsgi.wsgi_req->async_status = uwsgi.p[uwsgi.wsgi_req->uh.modifier1]->request(uwsgi.wsgi_req);
+	uwsgi.wsgi_req->suspended = 0;
+
+	return Qnil;
+}
+
+inline static void fiber_schedule_to_req() {
+
+	int id = uwsgi.wsgi_req->async_id;
+
+	if (!uwsgi.wsgi_req->suspended) {
+		ufiber.fib[id] = rb_fiber_new(uwsgi_fiber_request, Qnil);
+		rb_gc_register_address(&ufiber.fib[id]);
+		uwsgi.wsgi_req->suspended = 1;
+	}
+
+	rb_fiber_resume(ufiber.fib[id], 0, NULL);
+
+	if (uwsgi.wsgi_req->suspended) {
+		uwsgi.wsgi_req->async_status = UWSGI_AGAIN;
+	}
+
+}
+
+inline static void fiber_schedule_to_main(struct wsgi_request *wsgi_req) {
+
+	rb_fiber_yield(0, NULL);
+	uwsgi.wsgi_req = wsgi_req;
+}
+
+VALUE protected_async_loop() {
+
+	async_loop(NULL);
+	return Qnil;
+}
+
+void fiber_loop() {
+
+        int error = 0;
+
+	ufiber.fib = uwsgi_malloc( sizeof(VALUE) * uwsgi.async );
+
+        uwsgi.schedule_to_main = fiber_schedule_to_main;
+        uwsgi.schedule_to_req = fiber_schedule_to_req;
+
+	// must run all the rack/ruby plugins without protection
+	ur.unprotected = 1;
+
+        rb_protect(protected_async_loop, 0, &error);
+
+        if (error) {
+                uwsgi_ruby_exception();
+                exit(1);
+        }
+
+        // never here
+}
+
+int fiber_init() {
+	uwsgi_register_loop( (char *) "fiber", fiber_loop);
+	return 0;
+}
+
+
+struct uwsgi_plugin fiber_plugin = {
+
+	.name = "fiber",
+	.init = fiber_init,
+	.options = fiber_options,
+};

plugins/fiber/uwsgiplugin.py

@@ -0,0 +1,27 @@
+import os
+
+try:
+    RUBYPATH = os.environ['UWSGICONFIG_RUBYPATH']
+except:
+    RUBYPATH = 'ruby'
+
+NAME='fiber'
+CFLAGS = os.popen(RUBYPATH + " -e \"require 'rbconfig';print Config::CONFIG['CFLAGS']\"").read().rstrip().split()
+
+CFLAGS.append('-Wno-unused-parameter')
+
+includedir = os.popen(RUBYPATH + " -e \"require 'rbconfig';print Config::CONFIG['rubyhdrdir']\"").read().rstrip()
+if includedir == 'nil':
+    includedir = os.popen(RUBYPATH + " -e \"require 'rbconfig';print Config::CONFIG['archdir']\"").read().rstrip()
+    CFLAGS.append('-I' + includedir)
+else:
+    CFLAGS.append('-I' + includedir)
+    archdir = os.popen(RUBYPATH + " -e \"require 'rbconfig';print Config::CONFIG['archdir']\"").read().rstrip()
+    arch = os.popen(RUBYPATH + " -e \"require 'rbconfig';print Config::CONFIG['arch']\"").read().rstrip()
+    CFLAGS.append('-I' + archdir)
+    CFLAGS.append('-I' + archdir + '/' + arch)
+    CFLAGS.append('-I' + includedir + '/' + arch)
+LDFLAGS = []
+LIBS = []
+
+GCC_LIST = ['fiber']

plugins/greenlet/greenlet.c

@@ -0,0 +1,86 @@
+#include "../python/uwsgi_python.h"
+#include <greenlet/greenlet.h>
+
+extern struct uwsgi_server uwsgi;
+
+struct ugreenlet {
+	int enabled;
+	PyObject *callable;
+	PyGreenlet *main;
+	PyGreenlet **gl;
+} ugl;
+
+struct option greenlet_options[] = {
+	{"greenlet", no_argument, &ugl.enabled, 1},
+	{ 0, 0, 0, 0 }
+};
+
+PyObject *py_uwsgi_greenlet_request(PyObject * self, PyObject *args) {
+
+	uwsgi.wsgi_req->async_status = uwsgi.p[uwsgi.wsgi_req->uh.modifier1]->request(uwsgi.wsgi_req);
+	uwsgi.wsgi_req->suspended = 0;
+
+	Py_DECREF(ugl.gl[uwsgi.wsgi_req->async_id]);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyMethodDef uwsgi_greenlet_request_method[] = {{"uwsgi_greenlet_request", py_uwsgi_greenlet_request, METH_VARARGS, ""}};
+
+inline static void greenlet_schedule_to_req() {
+
+	int id = uwsgi.wsgi_req->async_id;
+
+	if (!uwsgi.wsgi_req->suspended) {
+		ugl.gl[id] = PyGreenlet_New(ugl.callable, NULL);
+		uwsgi.wsgi_req->suspended = 1;
+	}
+
+	PyGreenlet_Switch(ugl.gl[id], NULL, NULL);
+
+	if (uwsgi.wsgi_req->suspended) {
+		uwsgi.wsgi_req->async_status = UWSGI_AGAIN;
+	}
+
+}
+
+inline static void greenlet_schedule_to_main(struct wsgi_request *wsgi_req) {
+
+	PyGreenlet_Switch(ugl.main, NULL, NULL);
+	uwsgi.wsgi_req = wsgi_req;
+}
+
+
+int greenlet_init() {
+	return 0;
+}
+
+void greenlet_init_apps(void) {
+
+	if (!ugl.enabled) {
+		return;
+	}
+
+
+	PyGreenlet_Import();
+
+	ugl.gl = uwsgi_malloc( sizeof(PyGreenlet *) * uwsgi.async );
+	ugl.main = PyGreenlet_GetCurrent();
+	ugl.callable = PyCFunction_New(uwsgi_greenlet_request_method, NULL);
+	uwsgi_log("enabled greenlet engine\n");
+
+	uwsgi.schedule_to_main = greenlet_schedule_to_main;
+	uwsgi.schedule_to_req = greenlet_schedule_to_req;
+
+	return;
+
+}
+
+struct uwsgi_plugin greenlet_plugin = {
+
+	.name = "greenlet",
+	.init = greenlet_init,
+	.init_apps = greenlet_init_apps,
+	.options = greenlet_options,
+};

plugins/greenlet/uwsgiplugin.py

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

plugins/http/http.c

@@ -145,13 +145,13 @@ struct http_session {
 	struct uwsgi_rb_timer *timeout;
 };
 
-struct uwsgi_rb_timer *reset_timeout(struct http_session *uhttp_session) {
+static struct uwsgi_rb_timer *reset_timeout(struct http_session *uhttp_session) {
 
 	del_timeout(uhttp_session);
 	return add_timeout(uhttp_session);
 }
 
-void close_session(struct http_session **uhttp_table, struct http_session *uhttp_session) {
+static void close_session(struct http_session **uhttp_table, struct http_session *uhttp_session) {
 
 	close(uhttp_session->fd);
         uhttp_table[uhttp_session->fd] = NULL;
@@ -170,7 +170,7 @@ void close_session(struct http_session **uhttp_table, struct http_session *uhttp
 
 }
 
-void expire_timeouts(struct http_session **uhttp_table) {
+static void expire_timeouts(struct http_session **uhttp_table) {
 
         time_t current = time(NULL);
         struct uwsgi_rb_timer *urbt;
@@ -209,7 +209,7 @@ uint16_t http_add_uwsgi_header(struct http_session *h_session, struct iovec *iov
 
 	for(i=0;i<hhlen;i++) {
 		if (!status) {
-			hh[i] = toupper(hh[i]);
+			hh[i] = toupper((int)hh[i]);
 			if (hh[i] == '-') hh[i] = '_';
 			if (hh[i] == ':') {
 				status = 1;
@@ -429,12 +429,14 @@ void http_loop() {
 
 	struct uwsgi_rb_timer *min_timeout;
 	void *events;
+#ifndef __sun__
 	struct msghdr msg;
 	union {
                 struct cmsghdr cmsg;
                 char control [CMSG_SPACE (sizeof (int))];
         } msg_control;
         struct cmsghdr *cmsg;
+#endif
 
 	union uwsgi_sockaddr uhttp_addr;
         socklen_t uhttp_addr_len = sizeof(struct sockaddr_un);
@@ -501,6 +503,9 @@ void http_loop() {
 
 			if (interesting_fd == uhttp.server) {
 				new_connection = accept(uhttp.server, (struct sockaddr *) &uhttp_addr, &uhttp_addr_len);
+#ifdef UWSGI_EVENT_USE_PORT
+                                event_queue_add_fd_read(uhttp_queue, uhttp.server);
+#endif
 				if (new_connection < 0) {
 					continue;
 				}
@@ -531,10 +536,13 @@ void http_loop() {
 			}	
 			else if (interesting_fd == uhttp_subserver) {
 				len = recv(uhttp_subserver, bbuf, 4096, 0);
+#ifdef UWSGI_EVENT_USE_PORT
+                                event_queue_add_fd_read(uhttp_queue, uhttp_subserver);
+#endif
 				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 {
@@ -548,18 +556,23 @@ void http_loop() {
 					continue;
 				}
 
+				uhttp_session->timeout = reset_timeout(uhttp_session);
+
 				switch(uhttp_session->status) {
 
-					uhttp_session->timeout = reset_timeout(uhttp_session);
 
 					case HTTP_STATUS_RECV:
 						len = recv(uhttp_session->fd, uhttp_session->buffer + uhttp_session->h_pos, UMAX16-uhttp_session->h_pos, 0);
+#ifdef UWSGI_EVENT_USE_PORT
+						event_queue_add_fd_read(uhttp_queue, uhttp_session->fd);
+#endif
 						if (len <= 0) {
 							uwsgi_error("recv()");
 							close_session(uhttp_table, uhttp_session);
 							break;
 						}
 
+
 						uhttp_session->h_pos += len;
 
 						for(j=0;j<len;j++) {
@@ -615,9 +628,9 @@ void http_loop() {
 										uhttp_session->instance_address_len = uhttp_session->un->len;
 									}
 								}
-								else if (uwsgi.sockets_cnt > 0) {
-									uhttp_session->instance_address = uwsgi.sockets[0].name;
-									uhttp_session->instance_address_len = strlen(uwsgi.sockets[0].name);
+								else if (uwsgi.sockets) {
+									uhttp_session->instance_address = uwsgi.sockets->name;
+									uhttp_session->instance_address_len = strlen(uwsgi.sockets->name);
 								}
 
 								if (!uhttp_session->instance_address_len) {
@@ -681,6 +694,10 @@ void http_loop() {
                                                         	break;
 							}
 
+#ifdef __BIG_ENDIAN__
+        						uhttp_session->uh.pktsize = uwsgi_swap16(uhttp_session->uh.pktsize);
+#endif
+
 							uhttp_session->iov[0].iov_base = &uhttp_session->uh;
 							uhttp_session->iov[0].iov_len = 4;
 
@@ -690,8 +707,10 @@ void http_loop() {
 								uhttp_session->iov_len++;
 							}
 
+
+#ifndef __sun__
 							// fd passing: PERFORMANCE EXTREME BOOST !!!
-							if (uhttp_session->pass_fd) {
+							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;
@@ -721,11 +740,33 @@ void http_loop() {
                                                                 break;
 							}
 
+#endif
+#ifdef __sun__
+							if (uhttp_session->iov_len > IOV_MAX) {
+								int remains = uhttp_session->iov_len;
+								int iov_len;
+								while(remains) {
+									if (remains > IOV_MAX) {
+										iov_len = IOV_MAX;
+									}
+									else {
+										iov_len = remains;
+									}
+									if (writev(uhttp_session->instance_fd, uhttp_session->iov + (uhttp_session->iov_len-remains), iov_len) <= 0) {
+										uwsgi_error("writev()");
+										close_session(uhttp_table, uhttp_session);
+                                                        			break;
+									}
+									remains -= iov_len;
+								}
+							}
+#else
 							if (writev(uhttp_session->instance_fd, uhttp_session->iov, uhttp_session->iov_len) <= 0) {
 								uwsgi_error("writev()");
 								close_session(uhttp_table, uhttp_session);
                                                         	break;
 							}
+#endif
 
 							event_queue_fd_write_to_read(uhttp_queue, uhttp_session->instance_fd);
 							uhttp_session->status = HTTP_STATUS_RESPONSE;
@@ -738,6 +779,9 @@ void http_loop() {
 						// data from instance
 						if (interesting_fd == uhttp_session->instance_fd) {
 							len = recv(uhttp_session->instance_fd, bbuf, UMAX16, 0);
+#ifdef UWSGI_EVENT_USE_PORT
+                                                	event_queue_add_fd_read(uhttp_queue, uhttp_session->instance_fd);
+#endif
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("recv()");
 								close_session(uhttp_table, uhttp_session);
@@ -763,6 +807,9 @@ void http_loop() {
 
 							//uwsgi_log("receiving body...\n");
 							len = recv(uhttp_session->fd, bbuf, UMAX16, 0);
+#ifdef UWSGI_EVENT_USE_PORT
+                                                        event_queue_add_fd_read(uhttp_queue, uhttp_session->fd);
+#endif
 							if (len <= 0) {
 								if (len < 0) uwsgi_error("recv()");
 								close(uhttp_session->fd);
@@ -821,10 +868,8 @@ int http_init() {
 
 		if (!uhttp.nevents) uhttp.nevents = 64;
 
-		if (!uhttp.base && !uhttp.use_cache && !uhttp.to && !uwsgi.sockets_cnt && !uhttp.subscription_server && !uhttp.use_cluster) {
-			uwsgi.sockets[0].name = uwsgi_malloc(64);
-			uwsgi.sockets_cnt++;
-			snprintf(uwsgi.sockets[0].name, 64, "%d_%d.sock", (int) time(NULL), (int) getpid());
+		if (!uhttp.base && !uhttp.use_cache && !uhttp.to && !uwsgi.sockets && !uhttp.subscription_server && !uhttp.use_cluster) {
+			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,':'));
@@ -833,10 +878,17 @@ int http_init() {
 			uwsgi_log("unable to register the http gateway\n");
 			exit(1);
 		}
+
+		uwsgi_log("HTTP router/proxy bound on %s\n", uhttp.socket_name);
 	}
 
 	return 0;
 }
+
+struct uwsgi_help_item http_help[] = {
+	{ "http-to <addr>", "forward http requests to uwsgi instance bound at <addr>"},
+	{ 0, 0 }
+};
 	
 int http_opt(int i, char *optarg) {
 
@@ -887,8 +939,10 @@ int http_opt(int i, char *optarg) {
 
 struct uwsgi_plugin http_plugin = {
 
+	.name = "http",
         .options = http_options,
         .manage_opt = http_opt,
+	.help = http_help,
         .init = http_init,
 };
 

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,17 +16,17 @@ struct option nagios_options[] = {
 int nagios() {
 
 	char *tcp_port;
-	struct pollfd nagios_poll;
+	struct wsgi_request nagios_req;
 // connect and send
 
 	if (!use_nagios) {
 		return 1;
 	}
-	if (uwsgi.sockets[0].name == NULL) {
+	if (!uwsgi.sockets) {
 		fprintf(stdout, "UWSGI UNKNOWN: you have specified an invalid socket\n");
 		exit(3);
 	}
-	tcp_port = strchr(uwsgi.sockets[0].name, ':');
+	tcp_port = strchr(uwsgi.sockets->name, ':');
 	if (tcp_port == NULL) {
 		fprintf(stdout, "UWSGI UNKNOWN: you have specified an invalid socket\n");
 		exit(3);
@@ -34,27 +34,30 @@ int nagios() {
 
 	tcp_port[0] = 0;
 
-	nagios_poll.fd = connect_to_tcp(uwsgi.sockets[0].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)) {
+
+	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)) {
+	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/psgi/psgi.h

@@ -1,5 +1,9 @@
+#undef __USE_GNU
 #include "../../uwsgi.h"
 
+#ifdef __APPLE__
+#define HAS_BOOL 1
+#endif
 #include <EXTERN.h>
 #include <perl.h>
 #include "XSUB.h"
@@ -10,17 +14,30 @@ struct uwsgi_perl {
         int fd;
         char *psgibuffer;
         char *psgi;
+	char *locallib;
+	char *embedding[3];
         PerlInterpreter *main;
         pthread_key_t u_interpreter;
         PerlInterpreter **interp;
         SV *psgi_main;
         SV **psgi_func;
         CV *stream_responder;
+	HV *streaming_stash;
+	HV *input_stash;
+	HV *error_stash;
 
 };
 
-#define LONG_ARGS_PERL_BASE      17000 + ((5 + 1) * 100)
-#define LONG_ARGS_PSGI           LONG_ARGS_PERL_BASE + 1
+#define LONG_ARGS_PERL_BASE      	17000 + ((5 + 1) * 1000)
+#define LONG_ARGS_PSGI           	LONG_ARGS_PERL_BASE + 1
+#define LONG_ARGS_PERL_LOCAL_LIB	LONG_ARGS_PERL_BASE + 2
 
 void init_perl_embedded_module(void);
+void uwsgi_psgi_app(void);
 int psgi_response(struct wsgi_request *, PerlInterpreter *, AV*);
+
+#define psgi_xs(func) newXS("uwsgi::" #func, XS_##func, "uwsgi")
+#define psgi_check_args(x) if (items < x) Perl_croak(aTHX_ "Usage: uwsgi::%s takes %d arguments", __FUNCTION__ + 3, x)
+
+SV *uwsgi_perl_obj_call(SV *, char *);
+int uwsgi_perl_obj_can(SV *, char *, size_t);

plugins/psgi/psgi_loader.c

@@ -0,0 +1,315 @@
+#include "psgi.h" 
+
+extern struct uwsgi_server uwsgi;
+struct uwsgi_perl uperl;
+
+
+
+XS(XS_input_seek) {
+
+        dXSARGS;
+
+        psgi_check_args(1);
+        XSRETURN(0);
+}
+
+XS(XS_error) {
+	dXSARGS;
+
+        psgi_check_args(0);
+
+        ST(0) = sv_bless(newRV(sv_newmortal()), uperl.error_stash);
+        XSRETURN(1);
+}
+
+XS(XS_input) {
+
+        dXSARGS;
+        psgi_check_args(0);
+
+        ST(0) = sv_bless(newRV(sv_newmortal()), uperl.input_stash);
+        XSRETURN(1);
+}
+
+XS(XS_stream)
+{
+    dXSARGS;
+    struct wsgi_request *wsgi_req = current_wsgi_req();
+
+    psgi_check_args(1);
+
+    AV *response = (AV* ) SvREFCNT_inc(SvRV(ST(0))) ;
+
+	if (av_len(response) == 2) {
+
+#ifdef my_perl
+		while (psgi_response(wsgi_req, my_perl, response) != UWSGI_OK);
+#else
+		while (psgi_response(wsgi_req, uperl.main, response) != UWSGI_OK);
+#endif
+	}
+	else if (av_len(response) == 1) {
+#ifdef my_perl
+		while (psgi_response(wsgi_req, my_perl, response) != UWSGI_OK);
+#else
+		while (psgi_response(wsgi_req, uperl.main, response) != UWSGI_OK);
+#endif
+		SvREFCNT_dec(response);
+                ST(0) = sv_bless(newRV(sv_newmortal()), uperl.streaming_stash);
+                XSRETURN(1);
+	}
+	else {
+		uwsgi_log("invalid PSGI response: array size %d\n", av_len(response));
+	}
+
+	SvREFCNT_dec(response);
+	XSRETURN(0);
+
+}
+
+
+XS(XS_input_read) {
+
+        dXSARGS;
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+        int fd = -1;
+        char *tmp_buf;
+        ssize_t bytes = 0, len;
+        size_t remains;
+        SV *read_buf;
+
+        psgi_check_args(3);
+
+
+        read_buf = ST(1);
+        len = SvIV(ST(2));
+
+        // return empty string if no post_cl or pos >= post_cl
+        if (!wsgi_req->post_cl || (size_t) wsgi_req->post_pos >= wsgi_req->post_cl) {
+                sv_setpvn(read_buf, "", 0);
+                goto ret;
+        }
+
+        if (wsgi_req->body_as_file) {
+                fd = fileno((FILE *)wsgi_req->async_post);
+        }
+        else if (uwsgi.post_buffering > 0) {
+                fd = -1;
+                if (wsgi_req->post_cl <= (size_t) uwsgi.post_buffering) {
+                        fd = fileno((FILE *)wsgi_req->async_post);
+                }
+        }
+        else {
+                fd = wsgi_req->poll.fd;
+        }
+        // return the whole input
+        if (len <= 0) {
+                remains = wsgi_req->post_cl;
+        }
+        else {
+                remains = len ;
+        }
+
+        if (remains + wsgi_req->post_pos > wsgi_req->post_cl) {
+                remains = wsgi_req->post_cl - wsgi_req->post_pos;
+        }
+
+        if (remains <= 0) {
+                sv_setpvn(read_buf, "", 0);
+                goto ret;
+        }
+
+        // data in memory ?
+        if (fd == -1) {
+                sv_setpvn(read_buf, wsgi_req->post_buffering_buf, remains);
+                bytes = remains;
+                wsgi_req->post_pos += remains;
+
+        }
+
+        tmp_buf = uwsgi_malloc(remains);
+
+        if (uwsgi_waitfd(fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]) <= 0) {
+                free(tmp_buf);
+                croak("error waiting for wsgi.input data");
+                goto ret;
+        }
+
+        bytes = read(fd, tmp_buf, remains);
+        if (bytes < 0) {
+                free(tmp_buf);
+                croak("error reading wsgi.input data");
+                goto ret;
+        }
+
+        wsgi_req->post_pos += bytes;
+        sv_setpvn(read_buf, tmp_buf, bytes);
+
+        free(tmp_buf);
+
+ret:
+        XSRETURN_IV(bytes);
+}
+
+
+XS(XS_streaming_close) {
+
+        dXSARGS;
+        psgi_check_args(0);
+
+        XSRETURN(0);
+}
+
+XS(XS_streaming_write) {
+
+        dXSARGS;
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+        STRLEN blen;
+        char *body;
+
+        psgi_check_args(2);
+
+        body = SvPV(ST(1), blen);
+
+        wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, body, blen);
+
+        XSRETURN(0);
+}
+
+XS(XS_error_print) {
+
+	dXSARGS;
+        STRLEN blen;
+        char *body;
+
+        psgi_check_args(1);
+
+	if (items > 1) {
+        	body = SvPV(ST(1), blen);
+		uwsgi_log("%.*s", blen, body);
+	}
+
+        XSRETURN(0);
+}
+
+/* automatically generated */
+
+EXTERN_C void xs_init (pTHX);
+
+EXTERN_C void boot_DynaLoader (pTHX_ CV* cv);
+
+        EXTERN_C void
+xs_init(pTHX)
+{
+        char *file = __FILE__;
+        dXSUB_SYS;
+
+        /* DynaLoader is a special case */
+        newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
+
+        newXS("uwsgi::input::new", XS_input, "uwsgi::input");
+        newXS("uwsgi::input::read", XS_input_read, "uwsgi::input");
+        newXS("uwsgi::input::seek", XS_input_seek, "uwsgi::input");
+
+        uperl.input_stash = gv_stashpv("uwsgi::input", 0);
+
+        newXS("uwsgi::error::new", XS_error, "uwsgi::error");
+        newXS("uwsgi::error::print", XS_error_print, "uwsgi::print");
+        uperl.error_stash = gv_stashpv("uwsgi::error", 0);
+
+        uperl.stream_responder = newXS("uwsgi::stream", XS_stream, "uwsgi");
+
+        newXS("uwsgi::streaming::write", XS_streaming_write, "uwsgi::streaming");
+        newXS("uwsgi::streaming::close", XS_streaming_close, "uwsgi::streaming");
+
+        uperl.streaming_stash = gv_stashpv("uwsgi::streaming", 0);
+
+#ifdef UWSGI_EMBEDDED
+        init_perl_embedded_module();
+#endif
+
+}
+
+/* end of automagically generated part */
+
+
+void uwsgi_psgi_app() {
+
+        struct stat stat_psgi;
+
+        if (uperl.psgi) {
+
+                // two-pass loading: parse the script -> eval the script
+
+
+
+                if (uperl.locallib) {
+                        uwsgi_log("using %s as local::lib directory\n", uperl.locallib);
+                        uperl.embedding[1] = uwsgi_concat2("-Mlocal::lib=", uperl.locallib);
+                        uperl.embedding[2] = uperl.psgi;
+                        if (perl_parse(uperl.main, xs_init, 3, uperl.embedding, NULL)) {
+                                exit(1);
+                        }
+                }
+                else {
+                        uperl.embedding[1] = uperl.psgi;
+                        if (perl_parse(uperl.main, xs_init, 2, uperl.embedding, NULL)) {
+                                exit(1);
+                        }
+                }
+
+                perl_eval_pv("use IO::Handle;", 0);
+                perl_eval_pv("use IO::File;", 0);
+
+                SV *dollar_zero = get_sv("0", GV_ADD);
+                sv_setsv(dollar_zero, newSVpv(uperl.psgi, 0));
+
+                SV *dollar_slash = get_sv("/", GV_ADD);
+                sv_setsv(dollar_slash, newRV_inc(newSViv(uwsgi.buffer_size)));
+
+                uperl.fd = open(uperl.psgi, O_RDONLY);
+                if (uperl.fd < 0) {
+                        uwsgi_error_open(uperl.psgi);
+                        exit(1);
+                }
+
+                if (fstat(uperl.fd, &stat_psgi)) {
+                        uwsgi_error("fstat()");
+                        exit(1);
+                }
+
+                uperl.psgibuffer = malloc(stat_psgi.st_size + 1);
+                if (!uperl.psgibuffer) {
+                        uwsgi_error("malloc()");
+                        exit(1);
+                }
+
+                if (read(uperl.fd, uperl.psgibuffer, stat_psgi.st_size) != stat_psgi.st_size) {
+                        uwsgi_error("read()");
+                        exit(1);
+                }
+
+                uperl.psgibuffer[stat_psgi.st_size] = 0;
+
+                if (uwsgi.threads < 2) {
+                        uperl.psgi_main = perl_eval_pv(uwsgi_concat4("#line 1 ", uperl.psgi, "\n", uperl.psgibuffer), 0);
+                        if (!uperl.psgi_main) {
+                                uwsgi_log("unable to find PSGI function entry point.\n");
+                                exit(1);
+                        }
+
+                        if(SvTRUE(ERRSV)) {
+                                uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+                                exit(1);
+                        }
+
+                        free(uperl.psgibuffer);
+                        close(uperl.fd);
+                }
+
+                uwsgi_log("PSGI app (%s) loaded at %p\n", uperl.psgi, uperl.psgi_main);
+        }
+
+
+}
+

plugins/psgi/psgi_plugin.c

@@ -3,72 +3,302 @@
 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[] = {
 
         {"psgi", required_argument, 0, LONG_ARGS_PSGI},
+        {"perl-local-lib", required_argument, 0, LONG_ARGS_PERL_LOCAL_LIB},
         {0, 0, 0, 0},
 
 };
 
 extern struct http_status_codes hsc[];
 
-XS(XS_stream)
-{
-    dXSARGS;
-    struct wsgi_request *wsgi_req = current_wsgi_req();
-    SV *stack;
-    AV *response;
+SV *uwsgi_perl_obj_new(char *class, size_t class_len) {
 
-    uwsgi_log("args: %d %p\n", items, wsgi_req);
-    stack = ST(0);
-    uwsgi_log("type %d\n", SvTYPE(stack));
-    response = (AV* ) SvRV(stack) ;
+	SV *newobj;
+	// set current context ?
+	//dTHX;
+	dSP;
 
+	ENTER;
+	SAVETMPS;
+	PUSHMARK(SP);
+	XPUSHs(sv_2mortal(newSVpv( class, class_len)));
+	PUTBACK;
 
-    psgi_response(wsgi_req, my_perl, response);
+	call_method( "new", G_SCALAR);
 
-    //mXPUSHp("x", 1);
-    XSRETURN(0);
+	SPAGAIN;
+
+	newobj = POPs;	
+	PUTBACK;
+	FREETMPS;
+	LEAVE;
+
+	return newobj;
+	
+}
+
+SV *uwsgi_perl_call_stream(SV *func) {
+
+	SV *ret = NULL;
+        // set current context ?
+        //dTHX;
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs( sv_2mortal(newRV((SV*) uperl.stream_responder)));
+        PUTBACK;
+
+	call_sv( func, G_SCALAR | G_EVAL);
+
+	SPAGAIN;
+        if(SvTRUE(ERRSV)) {
+                uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+        }
+        else {
+                ret = SvREFCNT_inc(POPs);
+        }
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+}
+
+int uwsgi_perl_obj_can(SV *obj, char *method, size_t len) {
+
+	int ret;
+        // set current context ? needed for threading
+        //dTHX;
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs(obj);
+        XPUSHs(sv_2mortal(newSVpv(method, len)));
+        PUTBACK;
+
+        call_method( "can", G_SCALAR);
+
+        SPAGAIN;
+
+        ret = SvROK(POPs);
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
 
 }
 
-/* automatically generated */
 
-EXTERN_C void xs_init (pTHX);
+SV *uwsgi_perl_obj_call(SV *obj, char *method) {
 
-EXTERN_C void boot_DynaLoader (pTHX_ CV* cv);
+        SV *ret = NULL;
 
-	EXTERN_C void
-xs_init(pTHX)
-{
-	char *file = __FILE__;
-	dXSUB_SYS;
+        dSP;
 
-	/* DynaLoader is a special case */
-	newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
 
-	uperl.stream_responder = newXS("uwsgi::stream", XS_stream, "uwsgi");
+        XPUSHs(obj);
 
-#ifdef UWSGI_EMBEDDED
-	init_perl_embedded_module();
+        PUTBACK;
+
+        call_method( method, G_SCALAR | G_EVAL);
+
+        SPAGAIN;
+	if(SvTRUE(ERRSV)) {
+        	uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+        }
+	else {
+        	ret = SvREFCNT_inc(POPs);
+	}
+
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return ret;
+
+}
+
+
+AV *psgi_call(struct wsgi_request *wsgi_req, SV *psgi_func, SV *env) {
+
+	AV *ret = NULL;
+
+        dSP;
+
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs(env);
+	PUTBACK;
+
+	call_sv(psgi_func, G_SCALAR | G_EVAL);
+	SPAGAIN;
+
+        if(SvTRUE(ERRSV)) {
+                internal_server_error(wsgi_req, "exception raised");
+                uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+        }
+	else {
+		ret = (AV *) SvREFCNT_inc(SvRV(POPs));
+	}
+
+	PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+        return (AV *)ret;
+	
+}
+
+SV *build_psgi_env(struct wsgi_request *wsgi_req) {
+	int i;
+	HV *env = newHV();
+
+	// fill perl hash
+        for(i=0;i<wsgi_req->var_cnt;i++) {
+                if (wsgi_req->hvec[i+1].iov_len > 0) {
+
+                        // check for multiline header
+                        if (hv_exists(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len)) {
+                                SV **already_avalable_header = hv_fetch(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, 0);
+                                STRLEN hlen;
+                                char *old_value = SvPV(*already_avalable_header, hlen );
+                                char *multiline_header = uwsgi_concat3n(old_value, hlen, ", ", 2, wsgi_req->hvec[i+1].iov_base, wsgi_req->hvec[i+1].iov_len);
+                                if (!hv_store(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len,
+                                        newSVpv(multiline_header, hlen+wsgi_req->hvec[i+1].iov_len+2), 0))  { free(multiline_header); goto clear;}
+                                free(multiline_header);
+
+
+                        }
+                        else {
+                                if (!hv_store(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len,
+                                        newSVpv(wsgi_req->hvec[i+1].iov_base, wsgi_req->hvec[i+1].iov_len), 0)) goto clear;
+                        }
+                }
+                else {
+                        if (!hv_store(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, newSVpv("", 0), 0)) goto clear;
+                }
+                //uwsgi_log("%.*s = %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
+                i++;
+        }
+
+        // psgi.version
+        AV *av = newAV();
+        av_store( av, 0, newSViv(1));
+        av_store( av, 1, newSViv(1));
+        if (!hv_store(env, "psgi.version", 12, newRV_noinc((SV *)av ), 0)) goto clear;
+
+        if (uwsgi.numproc > 1) {
+                if (!hv_store(env, "psgi.multiprocess", 17, newSViv(1), 0)) goto clear;
+        }
+        else {
+                if (!hv_store(env, "psgi.multiprocess", 17, newSViv(0), 0)) goto clear;
+        }
+
+        if (uwsgi.threads > 1) {
+                if (!hv_store(env, "psgi.multithread", 16, newSViv(1), 0)) goto clear;
+        }
+        else {
+                if (!hv_store(env, "psgi.multithread", 16, newSViv(0), 0)) goto clear;
+        }
+
+        if (!hv_store(env, "psgi.run_once", 13, newSViv(0), 0)) goto clear;
+
+#ifdef UWSGI_ASYNC
+        if (uwsgi.async > 1) {
+                if (!hv_store(env, "psgi.nonblocking", 16, newSViv(1), 0)) goto clear;
+        }
+        else {
+#else
+                if (!hv_store(env, "psgi.nonblocking", 16, newSViv(0), 0)) goto clear;
 #endif
+
+#ifdef UWSGI_ASYNC
+        }
+#endif
+
+        if (!hv_store(env, "psgi.streaming", 14, newSViv(1), 0)) goto clear;
+
+	SV *us;
+        // psgi.url_scheme, honour HTTPS var or UWSGI_SCHEME
+        if (wsgi_req->scheme_len > 0) {
+                us = newSVpv(wsgi_req->scheme, wsgi_req->scheme_len);
+        }
+        else if (wsgi_req->https_len > 0) {
+                if (!strncasecmp(wsgi_req->https, "on", 2) || wsgi_req->https[0] == '1') {
+                        us = newSVpv("https", 5);
+                }
+                else {
+                        us = newSVpv("http", 4);
+                }
+        }
+        else {
+                us = newSVpv("http", 4);
+        }
+
+        if (!hv_store(env, "psgi.url_scheme", 15, us, 0)) goto clear;
+
+
+	SV *pi = uwsgi_perl_obj_new("uwsgi::input", 12);
+        if (!hv_store(env, "psgi.input", 10, pi, 0)) goto clear;
+	
+	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;
+
+	return newRV_noinc((SV *)env);
+
+clear:
+	SvREFCNT_dec((SV *)env);
+	return NULL;
 }
 
-/* end of automagically generated part */
-
-
 int uwsgi_perl_init(){
 
 
 	struct http_status_codes *http_sc;
 
-	int argc = 4;
-	char *embedding[] = { "", "-e", "-e", "0" };
+	int argc = 3;
+	uperl.embedding[0] = "";
+	uperl.embedding[1] = "-e";
+	uperl.embedding[2] = "0";
 
+	if (setenv("PLACK_ENV", "uwsgi", 0)) {
+		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
 	uwsgi_log("initializing Perl environment\n");
-	PERL_SYS_INIT3(&argc, (char ***) &embedding, &environ);
+#endif
+	PERL_SYS_INIT3(&argc, (char ***) &uperl.embedding, &environ);
 	uperl.main = perl_alloc();
 	if (!uperl.main) {
 		uwsgi_log("unable to allocate perl interpreter\n");
@@ -79,6 +309,7 @@ int uwsgi_perl_init(){
 	PERL_SET_CONTEXT(uperl.main);
 
 	PL_perl_destruct_level = 2;
+	PL_origalen = 1;
 	perl_construct(uperl.main);
 
 	// filling http status codes
@@ -87,65 +318,12 @@ int uwsgi_perl_init(){
 	}
 
 	PL_origalen = 1;
-	perl_parse(uperl.main, xs_init, 4, embedding, NULL);
-
-	perl_eval_pv("use IO::Handle;", 0);
 
 	return 1;
 
 }
 
-void uwsgi_psgi_app() {
-
-	struct stat stat_psgi;
-
-	if (uperl.psgi) {
-		uperl.fd = open(uperl.psgi, O_RDONLY);
-		if (uperl.fd < 0) {
-			uwsgi_error("open()");
-			exit(1);
-		}
-
-		if (fstat(uperl.fd, &stat_psgi)) {
-			uwsgi_error("fstat()");
-			exit(1);
-		}
-
-		uperl.psgibuffer = malloc(stat_psgi.st_size + 1);
-		if (!uperl.psgibuffer) {
-			uwsgi_error("malloc()");
-			exit(1);
-		}
-
-		if (read(uperl.fd, uperl.psgibuffer, stat_psgi.st_size) != stat_psgi.st_size) {
-			uwsgi_error("read()");
-			exit(1);
-		}
-
-		uperl.psgibuffer[stat_psgi.st_size] = 0;
-
-		if (uwsgi.threads < 2) {
-			uperl.psgi_main = perl_eval_pv(uperl.psgibuffer, 0);
-			if (!uperl.psgi_main) {
-				uwsgi_log("unable to find PSGI function entry point.\n");
-				exit(1);
-			}
-
-			if(SvTRUE(ERRSV)) {
-				uwsgi_log("%s\n", SvPV_nolen(ERRSV));
-				exit(1);
-			}
-
-			free(uperl.psgibuffer);
-			close(uperl.fd);
-		}
-
-		uwsgi_log("PSGI app (%s) loaded at %p\n", uperl.psgi, uperl.psgi_main);
-	}
-
-
-}
-
+#ifdef my_perl
 void uwsgi_perl_enable_threads() {
 	
 	int i;
@@ -192,24 +370,22 @@ void uwsgi_perl_enable_threads() {
 	
 
 }
+#endif
 
 
 
 int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 
-	HV *env;
-	SV **item;
-
-	AV *response;
-
-	SV *io_new, *io_err;
-	int i;
-
+	SV **harakiri;
 	SV *psgi_func = uperl.psgi_main;
 	// ugly hack
 	register PerlInterpreter *my_perl = uperl.main;
-	dSP;
 
+#ifdef UWSGI_ASYNC
+	if (wsgi_req->async_status == UWSGI_AGAIN) {
+		return psgi_response(wsgi_req, my_perl, wsgi_req->async_placeholder);	
+	}
+#endif
 
 	/* Standard PSGI request */
 	if (!wsgi_req->uh.pktsize) {
@@ -219,7 +395,6 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 
 
 	if (uwsgi_parse_vars(wsgi_req)) {
-		uwsgi_log("Invalid PSGI request. skip.\n");
 		return -1;
 	}
 
@@ -236,116 +411,48 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	SAVETMPS;
 
 
-	env = (HV*) sv_2mortal((SV*)newHV());
+	wsgi_req->async_environ = build_psgi_env(wsgi_req);
+	if (!wsgi_req->async_environ) goto clear;
 
+	wsgi_req->async_result = psgi_call(wsgi_req, psgi_func, wsgi_req->async_environ);
+	if (!wsgi_req->async_result) goto clear;
 
-	// fill perl hash
-	for(i=0;i<wsgi_req->var_cnt;i++) {
-		if (wsgi_req->hvec[i+1].iov_len > 0) {
-
-			item = hv_store(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len,
-					newSVpv(wsgi_req->hvec[i+1].iov_base, wsgi_req->hvec[i+1].iov_len), 0);
+	if (SvTYPE((AV *)wsgi_req->async_result) == SVt_PVCV) {
+		SV *stream_result = uwsgi_perl_call_stream((SV*)wsgi_req->async_result);		
+		if (!stream_result) {
+			internal_server_error(wsgi_req, "exception raised");
 		}
 		else {
-			item = hv_store(env, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, newSVpv("", 0), 0);
+			SvREFCNT_dec(stream_result);
 		}
-		//uwsgi_log("%.*s = %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
-		i++;
+		goto clear2;
 	}
 
-
-	SV *us = newSVpv("http", 4);
-	item = hv_store(env, "psgi.url_scheme", 15, us, 0);
-
-
-	SV* iohandle = newSVpv( "IO::Handle", 10 );
-
-
-	PUSHMARK(SP);
-	XPUSHs( sv_2mortal(iohandle));
-	PUTBACK;
-	perl_call_method( "new", G_SCALAR);
-	SPAGAIN;
-	io_new = POPs;
-
-	PUSHMARK(SP);
-	XPUSHs( io_new );
-	XPUSHs( sv_2mortal(newSViv( wsgi_req->poll.fd)));
-	XPUSHs( sv_2mortal(newSVpv( "r", 1)));
-	PUTBACK;
-	perl_call_method( "fdopen", G_SCALAR);
-	SPAGAIN;
-
-
-
-
-	SV *pi = SvREFCNT_inc(POPs);
-	item = hv_store(env, "psgi.input", 10, pi, 0);
-
-
-	PUSHMARK(SP);
-	XPUSHs( newSVpv( "IO::Handle", 10 ));
-	PUTBACK;
-	perl_call_method( "new", G_SCALAR);
-	SPAGAIN;
-	io_err = POPs;
-
-	PUSHMARK(SP);
-	XPUSHs( io_err );
-	XPUSHs( sv_2mortal( newSViv( 2 )));
-	XPUSHs( sv_2mortal( newSVpv( "w", 1)));
-	PUTBACK;
-	perl_call_method( "fdopen", G_SCALAR);
-	SPAGAIN;
-
-	SV *pe = SvREFCNT_inc(POPs);
-	item = hv_store(env, "psgi.errors", 11, pe, 0);
-
-
-	PUSHMARK(SP);
-	XPUSHs( sv_2mortal(newRV((SV *)env )) );
-	PUTBACK;
-
-
-	perl_call_sv(psgi_func, G_SCALAR);
-
-	
-	if(SvTRUE(ERRSV)) {
-		uwsgi_log("%s\n", SvPV_nolen(ERRSV));
-		goto clear;
-	}
-	SPAGAIN;
-	// no leaks to here
-
-	// dereference output
-	response = (AV *) SvRV( POPs );
-
-	//uwsgi_log("response: %p %d\n", response, SvTYPE(response));
-
-	if (SvTYPE(response) == SVt_PVCV) {
-		uwsgi_log("streaming response\n");
-			
-		PUSHMARK(SP);
-        	XPUSHs( newRV((SV*) uperl.stream_responder));
-        	PUTBACK;
-
-        	perl_call_sv( (SV*)response, G_SCALAR);
-
-		if(SvTRUE(ERRSV)) {
-			uwsgi_log("%s\n", SvPV_nolen(ERRSV));
+	while (psgi_response(wsgi_req, my_perl, wsgi_req->async_result) != UWSGI_OK) {
+#ifdef UWSGI_ASYNC
+		if (uwsgi.async > 1) {
+			FREETMPS;
+			LEAVE;
+			return UWSGI_AGAIN;
 		}
-
-		goto clear;
+#endif
 	}
 
-	psgi_response(wsgi_req, my_perl, response);
+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:
 
 	FREETMPS;
 	LEAVE;
 
-	return 0;
+	return UWSGI_OK;
 }
 
 
@@ -353,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) {
@@ -382,6 +495,9 @@ int uwsgi_perl_manage_options(int i, char *optarg) {
                 case LONG_ARGS_PSGI:
                         uperl.psgi = optarg;
                         return 1;
+                case LONG_ARGS_PERL_LOCAL_LIB:
+                        uperl.locallib = optarg;
+                        return 1;
         }
 
         return 0;
@@ -412,7 +528,9 @@ struct uwsgi_plugin psgi_plugin = {
 	.init_apps = uwsgi_psgi_app,
 	//.magic = uwsgi_perl_magic,
 	//.help = uwsgi_perl_help,
+#ifdef my_perl
 	.enable_threads = uwsgi_perl_enable_threads,
+#endif
 	.manage_opt = uwsgi_perl_manage_options,
 	.init_thread = uwsgi_perl_init_thread,
 	.request = uwsgi_perl_request,

plugins/psgi/psgi_response.c

@@ -1,5 +1,7 @@
 #include "psgi.h"
 
+extern struct uwsgi_server uwsgi;
+
 /* statistically ordered */
 struct http_status_codes hsc[] = {
         {"200", "OK"},
@@ -55,16 +57,61 @@ 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;
-	dSP;
+	SV **harakiri;
+
+#ifdef UWSGI_ASYNC
+	if (wsgi_req->async_status == UWSGI_AGAIN) {
+
+		wsgi_req->async_force_again = 0;
+
+		wsgi_req->switches++;
+                SV *chunk = uwsgi_perl_obj_call(wsgi_req->async_placeholder, "getline");
+		if (!chunk) {
+			internal_server_error(wsgi_req, "exception raised");
+			return UWSGI_OK;
+		}
+
+		if (wsgi_req->async_force_again) {
+			SvREFCNT_dec(chunk);
+			return UWSGI_AGAIN;
+		}
+
+                chitem = SvPV( chunk, hlen);
+
+                if (hlen <= 0) {
+			SvREFCNT_dec(chunk);
+			SV *closed = uwsgi_perl_obj_call(wsgi_req->async_placeholder, "close");
+                	if (closed) {
+                        	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);
+
+			return UWSGI_OK;
+                }
+
+                wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, chitem, hlen);
+		SvREFCNT_dec(chunk);
+
+		return UWSGI_AGAIN;
+	}
+#endif
 
 	status_code = av_fetch(response, 0, 0);
+	if (!status_code) { uwsgi_log("invalid PSGI status code\n"); return UWSGI_OK;}
 
         wsgi_req->hvec[0].iov_base = "HTTP/1.1 ";
         wsgi_req->hvec[0].iov_len = 9;
 
-        //uwsgi_log("setting status %d %d\n", SvTYPE(*status_code), SvIV(*status_code));
-
         wsgi_req->hvec[1].iov_base = SvPV(*status_code, hlen);
+
         wsgi_req->hvec[1].iov_len = 3;
 
         wsgi_req->status = atoi(wsgi_req->hvec[1].iov_base);
@@ -92,8 +139,10 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
         wsgi_req->hvec[4].iov_len = 2;
 
         hitem = av_fetch(response, 1, 0);
+	if (!hitem) { uwsgi_log("invalid PSGI headers\n"); return UWSGI_OK;}
 
         headers = (AV *) SvRV(*hitem);
+	if (!headers) { uwsgi_log("invalid PSGI headers\n"); return UWSGI_OK;}
 
         base = 5;
 
@@ -122,34 +171,76 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
 	vi = (i*2)+base;
         wsgi_req->hvec[vi].iov_base = "\r\n"; wsgi_req->hvec[vi].iov_len = 2;
 
-        if ( !(wsgi_req->headers_size = writev(wsgi_req->poll.fd, wsgi_req->hvec, vi+1)) ) {
+        if ( !(wsgi_req->headers_size += wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, vi+1)) ) {
                 uwsgi_error("writev()");
         }
 
         hitem = av_fetch(response, 2, 0);
 
-        if (SvTYPE(SvRV(*hitem)) == SVt_PVGV || SvTYPE(SvRV(*hitem)) == SVt_PVHV) {
+	if (!hitem) {
+		return UWSGI_OK;
+	}
+
+	if (!SvRV(*hitem)) { uwsgi_log("invalid PSGI response body\n") ; return UWSGI_OK; }
+	
+        if (SvTYPE(SvRV(*hitem)) == SVt_PVGV || SvTYPE(SvRV(*hitem)) == SVt_PVHV || SvTYPE(SvRV(*hitem)) == SVt_PVMG) {
+
+		// respond to fileno ?
+		if (uwsgi.async < 2) {
+			if (uwsgi_perl_obj_can(*hitem, "fileno", 6)) {
+				SV *fn = uwsgi_perl_obj_call(*hitem, "fileno");
+				wsgi_req->sendfile_fd = SvIV(fn);
+				SvREFCNT_dec(fn);	
+				wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
+				return UWSGI_OK;
+			}
+			
+			if (uwsgi_perl_obj_can(*hitem, "path", 4)) {
+				SV *p = uwsgi_perl_obj_call(*hitem, "path");
+				wsgi_req->sendfile_fd = open(SvPV_nolen(p), O_RDONLY);
+				SvREFCNT_dec(p);	
+				wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
+				close(wsgi_req->sendfile_fd);
+				return UWSGI_OK;
+			}
+		}
 
                 for(;;) {
-                        PUSHMARK(SP);
-                        XPUSHs(*hitem);
-                        PUTBACK;
-                        perl_call_method("getline", G_SCALAR);
-                        SPAGAIN;
 
-                        if(SvTRUE(ERRSV)) {
-                                uwsgi_log("%s\n", SvPV_nolen(ERRSV));
-                                break;
-                        }
-
-                        SV *chunk = POPs;
+			wsgi_req->switches++;
+                        SV *chunk = uwsgi_perl_obj_call(*hitem, "getline");
+			if (!chunk) {
+				internal_server_error(wsgi_req, "exception raised");
+				break;
+			}
                         chitem = SvPV( chunk, hlen);
+#ifdef UWSGI_ASYNC
+			if (uwsgi.async > 1 && wsgi_req->async_force_again) {
+				SvREFCNT_dec(chunk);
+				wsgi_req->async_status = UWSGI_AGAIN;
+				wsgi_req->async_placeholder = (SV *) *hitem;
+				return UWSGI_AGAIN;
+			}
+#endif
                         if (hlen <= 0) {
+				SvREFCNT_dec(chunk);
                                 break;
                         }
-                        wsgi_req->response_size = write(wsgi_req->poll.fd, chitem, hlen);
+                        wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, chitem, hlen);
+			SvREFCNT_dec(chunk);
+#ifdef UWSGI_ASYNC
+			if (uwsgi.async > 1) {
+				wsgi_req->async_status = UWSGI_AGAIN;
+				wsgi_req->async_placeholder = (SV *) *hitem;
+				return UWSGI_AGAIN;
+			}
+#endif
                 }
 
+		SV *closed = uwsgi_perl_obj_call(*hitem, "close");
+		if (closed) {
+			SvREFCNT_dec(closed);
+		}
 
         }
         else if (SvTYPE(SvRV(*hitem)) == SVt_PVAV)  {
@@ -159,7 +250,7 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
                 for(i=0; i<=av_len(body); i++) {
                         hitem = av_fetch(body,i,0);
                         chitem = SvPV(*hitem, hlen);
-                        wsgi_req->response_size = write(wsgi_req->poll.fd, chitem, hlen);
+                        wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, chitem, hlen);
                 }
 
         }
@@ -167,6 +258,6 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
                 uwsgi_log("unsupported response body type: %d\n", SvTYPE(SvRV(*hitem)));
         }
 	
-	return 1;
+	return UWSGI_OK;
 
 }

plugins/psgi/uwsgi_plmodule.c

@@ -2,12 +2,85 @@
 
 extern struct uwsgi_server uwsgi;
 
-#define psgi_xs(func) newXS("uwsgi::" #func, XS_##func, "uwsgi")
-#define psgi_check_args(x) if (items < x) Perl_croak(aTHX_ "Usage: uwsgi::%s takes %d arguments", __FUNCTION__ + 3, x)
+#ifdef UWSGI_ASYNC
+
+
+XS(XS_async_sleep) {
+
+        dXSARGS;
+        int timeout ;
+
+        psgi_check_args(1);
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+
+        timeout = SvIV(ST(0));
+
+        if (timeout >= 0) {
+		async_add_timeout(wsgi_req, timeout);
+        }
+
+	wsgi_req->async_force_again = 1;
+
+	XSRETURN_UNDEF;
+}
+
+
+
+XS(XS_wait_fd_read) {
+
+	dXSARGS;
+        int fd, timeout = 0;
+
+	psgi_check_args(1);
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+
+	fd = SvIV(ST(0));
+	if (items > 1) {
+		timeout = SvIV(ST(1));
+	} 
+
+        if (fd >= 0) {
+                async_add_fd_read(wsgi_req, fd, timeout);
+        }
+
+	wsgi_req->async_force_again = 1;
+
+	XSRETURN_UNDEF;
+}
+
+
+XS(XS_wait_fd_write) {
+
+        dXSARGS;
+        int fd, timeout = 0;
+
+        psgi_check_args(1);
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+
+        fd = SvIV(ST(0));
+        if (items > 1) {
+                timeout = SvIV(ST(1));
+        }
+
+        if (fd >= 0) {
+                async_add_fd_write(wsgi_req, fd, timeout);
+        }
+
+	wsgi_req->async_force_again = 1;
+
+	XSRETURN_UNDEF;
+}
+
+#endif
+
 
 XS(XS_reload) {
     dXSARGS;
-    items = 0;
+
+	psgi_check_args(0);
 
     uwsgi_log("SENDING HUP TO %d\n", (int) uwsgi.workers[0].pid);
     if (kill(uwsgi.workers[0].pid, SIGHUP)) {
@@ -57,6 +130,27 @@ XS(XS_cache_get) {
 	
 }
 
+XS(XS_log) {
+
+	dXSARGS;
+
+	psgi_check_args(1);
+
+	uwsgi_log("%s", SvPV_nolen(ST(0)));
+
+	XSRETURN_UNDEF;
+}
+
+XS(XS_async_connect) {
+
+	dXSARGS;
+	psgi_check_args(1);
+
+	ST(0) = newSViv(uwsgi_connect(SvPV_nolen(ST(0)), 0, 1));
+
+	XSRETURN(1);
+}
+
 XS(XS_call) {
 
 	dXSARGS;
@@ -88,11 +182,30 @@ XS(XS_call) {
 }
 
 
+XS(XS_suspend) {
+
+	dXSARGS;
+	psgi_check_args(0);
+
+	struct wsgi_request *wsgi_req = current_wsgi_req();
+
+	wsgi_req->async_force_again = 0;
+
+        if (uwsgi.schedule_to_main) uwsgi.schedule_to_main(wsgi_req);
+
+	XSRETURN_UNDEF;
+}
 
 void init_perl_embedded_module() {
 	psgi_xs(reload);
 	psgi_xs(cache_set);
 	psgi_xs(cache_get);
 	psgi_xs(call);
+	psgi_xs(wait_fd_read);
+	psgi_xs(wait_fd_write);
+	psgi_xs(async_sleep);
+	psgi_xs(log);
+	psgi_xs(async_connect);
+	psgi_xs(suspend);
 }
 

plugins/psgi/uwsgiplugin.py

@@ -4,4 +4,4 @@ NAME='psgi'
 CFLAGS = [os.popen('perl -MExtUtils::Embed -e ccopts').read().rstrip()]
 LDFLAGS = [os.popen('perl -MExtUtils::Embed -e ldopts').read().rstrip()]
 LIBS = []
-GCC_LIST = ['uwsgi_plmodule', 'psgi_response', 'psgi_plugin']
+GCC_LIST = ['uwsgi_plmodule', 'psgi_loader', 'psgi_response', 'psgi_plugin']

plugins/pyerl/pyerl.c

@@ -72,6 +72,7 @@ PyObject *erl_to_py(ei_x_buff* x) {
 			ei_decode_string(x->buff, &x->index, atom);
 			pobj = PyString_FromString(atom);
 			free(atom);
+			Py_INCREF(pobj);
 			return pobj;
 		case ERL_ATOM_EXT:
 			atom = uwsgi_malloc(esize+1);
@@ -84,6 +85,7 @@ PyObject *erl_to_py(ei_x_buff* x) {
 			pobj = PyUnicode_FromString(atom);
 #endif
 			free(atom);
+			Py_INCREF(pobj);
 			return pobj;
 		case ERL_SMALL_TUPLE_EXT:
                 case ERL_LARGE_TUPLE_EXT:
@@ -94,6 +96,7 @@ PyObject *erl_to_py(ei_x_buff* x) {
 				PyTuple_SetItem(pobj, i, zero);
 				Py_DECREF(zero);
 			}		
+			Py_INCREF(pobj);
 			return pobj;
 		case ERL_LIST_EXT:
 		case ERL_NIL_EXT:
@@ -108,12 +111,14 @@ PyObject *erl_to_py(ei_x_buff* x) {
 				PyList_Append(pobj, zero);
 				Py_DECREF(zero);
 			}
+			Py_INCREF(pobj);
 			return pobj;	
 		case ERL_BINARY_EXT:
 			binary = uwsgi_malloc(esize);
 			ei_decode_binary(x->buff, &x->index, binary, &bin_size);
 			pobj = PyString_FromStringAndSize(binary, bin_size);
 			free(binary);
+			Py_INCREF(pobj);
 			return pobj;
 		case ERL_PID_EXT:
 			ei_decode_pid(x->buff, &x->index, &epid);	
@@ -121,6 +126,7 @@ PyObject *erl_to_py(ei_x_buff* x) {
 			PyTuple_SetItem(pobj, 0, PyInt_FromLong(epid.num));
 			PyTuple_SetItem(pobj, 1, PyInt_FromLong(epid.serial));
 			PyTuple_SetItem(pobj, 2, PyInt_FromLong(epid.creation));
+			Py_INCREF(pobj);
 			return pobj;
 		default:
 			ei_skip_term(x->buff, &x->index);
@@ -292,6 +298,41 @@ recv:
         return Py_None;
 }
 
+void pyerl_call_registered(void *func, ei_x_buff *x) {
+
+	PyObject *pyargs = PyTuple_New(1);
+
+	PyTuple_SetItem(pyargs, 0, erl_to_py(x));
+	
+        python_call((PyObject *) func, pyargs, 0);
+}
+
+PyObject *pyerl_register_process(PyObject * self, PyObject * args) {
+
+	char *name;
+	PyObject *callable;
+
+	if (!PyArg_ParseTuple(args, "sO:erlang_register_process", &name, &callable)) {
+                return NULL;
+        }
+
+	if (uerl.uep_cnt >= MAX_UWSGI_ERLANG_PROCESSES)
+	return PyErr_Format(PyExc_ValueError, "You can define max %d erlang registered processes", MAX_UWSGI_ERLANG_PROCESSES);
+
+	if (strlen(name) > 0xff-1)
+	return PyErr_Format(PyExc_ValueError, "Invalid erlang process name");
+
+	strcpy(uerl.uep[uerl.uep_cnt].name, name);
+	uerl.uep[uerl.uep_cnt].plugin = pyerl_call_registered;
+	uerl.uep[uerl.uep_cnt].func = callable;
+
+	uerl.uep_cnt++;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+	
+}
+
 PyObject *pyerl_recv(PyObject * self, PyObject * args) {
 
 	ei_x_buff x;
@@ -401,6 +442,7 @@ static PyMethodDef uwsgi_pyerl_methods[] = {
         {"erlang_rpc", pyerl_rpc, METH_VARARGS, ""},
         {"erlang_lock", pyerl_lock, METH_VARARGS, ""},
         {"erlang_unlock", pyerl_unlock, METH_VARARGS, ""},
+        {"erlang_register_process", pyerl_register_process, METH_VARARGS, ""},
         {NULL, NULL},
 };
 
@@ -426,7 +468,7 @@ int py_to_erl(PyObject *pobj, ei_x_buff *x) {
 		ei_x_encode_empty_list(x);
         }
         else if (PyString_Check(pobj)) {
-                ei_x_encode_string(x, PyString_AsString(pobj));
+                ei_x_encode_binary(x, PyString_AsString(pobj), PyString_Size(pobj));
         }
 	else if (PyUnicode_Check(pobj)) {
                 ei_x_encode_atom(x, PyString_AsString(pobj));
@@ -435,11 +477,13 @@ int py_to_erl(PyObject *pobj, ei_x_buff *x) {
                 ei_x_encode_long(x, PyInt_AsLong(pobj));
         }
         else if (PyList_Check(pobj)) {
-		ei_x_encode_list_header(x, PyList_Size(pobj));
-                for (i = 0; i < PyList_Size(pobj); i++) {
-                        pobj2 = PyList_GetItem(pobj, i);
-			if (py_to_erl(pobj2, x) < 0) return -1;
-                }
+		if (PyList_Size(pobj) > 0) {
+			ei_x_encode_list_header(x, PyList_Size(pobj));
+                	for (i = 0; i < PyList_Size(pobj); i++) {
+                        	pobj2 = PyList_GetItem(pobj, i);
+				if (py_to_erl(pobj2, x) < 0) return -1;
+                	}
+		}
 		ei_x_encode_empty_list(x);
         }
 	else if (PyTuple_Check(pobj)) {

plugins/python/gil.c

@@ -4,13 +4,26 @@ 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();
+	PyEval_ReleaseLock();	
+#else
+	pthread_setspecific(up.upt_gil_key, (void *) PyThreadState_Get());
+	PyEval_SaveThread();
+#endif
 }
 
 void gil_fake_get() {}

plugins/python/profiler.c

@@ -0,0 +1,34 @@
+#include "uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+
+#ifdef HAS_NOT_PyFrame_GetLineNumber
+int PyFrame_GetLineNumber(PyFrameObject *frame) {
+	if (frame->f_trace) {
+		return frame->f_lineno;
+	}
+	else {
+		return PyCode_Addr2Line(frame->f_code, frame->f_lasti);
+	}
+}
+#endif
+
+int uwsgi_python_profiler_call(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg) {
+
+	switch(what) {
+		case PyTrace_CALL:
+			uwsgi_log("[uWSGI Python profiler] CALL: %s (line %d) -> %s %d args, stacksize %d\n",
+				PyString_AsString(frame->f_code->co_filename),
+				PyFrame_GetLineNumber(frame),
+				PyString_AsString(frame->f_code->co_name), frame->f_code->co_argcount, frame->f_code->co_stacksize);
+			break;
+		case PyTrace_C_CALL:
+			uwsgi_log("[uWSGI Python profiler] C CALL: %s (line %d) -> %s %d args, stacksize %d\n",
+				PyString_AsString(frame->f_code->co_filename),
+				PyFrame_GetLineNumber(frame),
+				PyEval_GetFuncName(arg), frame->f_code->co_argcount, frame->f_code->co_stacksize);
+			break;
+	}
+
+	return 0;
+}

plugins/python/pyloader.c

@@ -4,6 +4,8 @@
 
    exit(1) on every malloc error: apps can be dinamically loaded so on memory problem
    it is better to let the master process manager respawn the worker.
+
+   TODO dynamic loading on prefork+thread looks flaky... NEED TO FIX IT
    */
 
 extern struct uwsgi_server uwsgi;
@@ -36,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 = "";
 	}
@@ -48,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 {
@@ -112,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();
                         		}
 
@@ -125,7 +125,6 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
         	}
 	}
 
-
 	if (interpreter == NULL && id) {
 		wi->interpreter = Py_NewInterpreter();
 		if (!wi->interpreter) {
@@ -149,6 +148,14 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		wi->interpreter = up.main_thread;
 	}
 
+	if (wsgi_req->touch_reload_len) {
+		struct stat trst;
+		char *touch_reload = uwsgi_strncopy(wsgi_req->touch_reload, wsgi_req->touch_reload_len);
+		if (!stat(touch_reload, &trst)) {
+			wi->touch_reload = touch_reload;
+			wi->touch_reload_mtime = trst.st_mtime;
+		}
+	}
 
 	wi->callable = up.loaders[loader](arg1);
 
@@ -296,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);
@@ -312,7 +320,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		uwsgi_log( "Web3 application %d (SCRIPT_NAME=%.*s) ready on interpreter %p", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter);
 	}
 	else {
-		uwsgi_log( "WSGI application %d (SCRIPT_NAME=%.*s) ready on interpreter %p", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter);
+		uwsgi_log( "WSGI application %d (SCRIPT_NAME=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 
 	if (!wsgi_req->script_name_len) {
@@ -431,6 +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)] = '(';
 		if (tmp_callable) {
 			return python_call(tmp_callable, PyTuple_New(0), 0);
 		}
@@ -511,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) {
@@ -520,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

@@ -3,6 +3,8 @@
 extern struct uwsgi_server uwsgi;
 struct uwsgi_python up;
 
+#include <glob.h>
+
 extern PyTypeObject uwsgi_InputType;
 
 struct option uwsgi_python_options[] = {
@@ -13,9 +15,17 @@ struct option uwsgi_python_options[] = {
 	{"callable", required_argument, 0, LONG_ARGS_CALLABLE},
 	{"test", required_argument, 0, 'j'},
 	{"home", required_argument, 0, 'H'},
+	{"virtualenv", required_argument, 0, 'H'},
+	{"venv", required_argument, 0, 'H'},
+	{"pyhome", required_argument, 0, 'H'},
 	{"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'},
@@ -32,6 +42,29 @@ struct option uwsgi_python_options[] = {
 	{0, 0, 0, 0},
 };
 
+struct uwsgi_help_item uwsgi_python_help[] = {
+
+{"module <module>" ,"name of python config module"},
+{"optimize <n>", "set python optimization level to <n>"},
+{"home <path>", "set python home/virtualenv"},
+{"pyhome <path>", "set python home/virtualenv"},
+{"virtualenv <path>", "set python home/virtualenv"},
+{"venv <path>", "set python home/virtualenv"},
+{"callable <callable>", "set the callable (default 'application')"},
+{"paste <config:/egg:>", "load applications using paste.deploy.loadapp()"},
+{"pythonpath <dir>", "add <dir> to PYTHONPATH"},
+{"python-path <dir>", "add <dir> to PYTHONPATH"},
+{"pp <dir>", "add <dir> to PYTHONPATH"},
+{"pyargv <args>", "assign args to python sys.argv"},
+{"wsgi-file <file>", "load the <file> wsgi file"},
+{"file <file>", "use python file instead of python module for configuration"},
+{"eval <code>", "evaluate code for app configuration"},
+{"ini-paste <inifile>", "path of ini config file that contains paste configuration"},
+
+
+ { 0, 0},
+};
+
 /* this routine will be called after each fork to reinitialize the various locks */
 void uwsgi_python_pthread_prepare(void) {
 	pthread_mutex_lock(&up.lock_pyloaders);
@@ -59,20 +92,21 @@ int uwsgi_python_init() {
         uwsgi_log("Python version: %.*s %s\n", pyversion-Py_GetVersion(), Py_GetVersion(), Py_GetCompiler()+1);
 
 	if (up.home != NULL) {
-		uwsgi_log("Setting PythonHome to %s...\n", up.home);
 #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
+		uwsgi_log("Set PythonHome to %s\n", up.home);
 	}
 
 #ifdef PYTHREE
@@ -108,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
@@ -156,49 +195,69 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	char *real_filename = filename;
 
 
-	pyfile = fopen(filename, "r");
-	if (!pyfile) {
-		uwsgi_log("failed to open python file %s\n", filename);
-		exit(1);
-	}
+	if (strncmp(filename, "http://", 7) && strncmp(filename, "sym://", 6)) {
 
-	if (fstat(fileno(pyfile), &pystat)) {
-		uwsgi_error("fstat()");
-		exit(1);
-	}
-
-	if (S_ISDIR(pystat.st_mode)) {
-		is_a_package = 1;
-		fclose(pyfile);
-		real_filename = uwsgi_concat2(filename, "/__init__.py");
-		pyfile = fopen(real_filename, "r");
+		pyfile = fopen(filename, "r");
 		if (!pyfile) {
-			uwsgi_error("fopen()");
-			exit(1);
+			uwsgi_log("failed to open python file %s\n", filename);
+			return NULL;
+		}
+
+		if (fstat(fileno(pyfile), &pystat)) {
+			uwsgi_error("fstat()");
+			return NULL;
+		}
+
+		if (S_ISDIR(pystat.st_mode)) {
+			is_a_package = 1;
+			fclose(pyfile);
+			real_filename = uwsgi_concat2(filename, "/__init__.py");
+			pyfile = fopen(real_filename, "r");
+			if (!pyfile) {
+				uwsgi_error_open(real_filename);
+				free(real_filename);
+				fclose(pyfile);
+				return NULL;
+			}
+		}
+
+		py_file_node = PyParser_SimpleParseFile(pyfile, real_filename, Py_file_input);
+		if (!py_file_node) {
+			PyErr_Print();
+			uwsgi_log("failed to parse file %s\n", real_filename);
+			free(real_filename);
+			fclose(pyfile);
+			return NULL;
+		}
+
+		fclose(pyfile);
+	}
+	else {
+		int pycontent_size = 0;
+		char *pycontent = uwsgi_open_and_read(filename, &pycontent_size, 1, NULL);
+
+		if (pycontent) {
+			py_file_node = PyParser_SimpleParseString(pycontent, Py_file_input);
+			if (!py_file_node) {
+				PyErr_Print();
+				uwsgi_log("failed to parse url %s\n", real_filename);
+				return NULL;
+			}
 		}
 	}
 
-	py_file_node = PyParser_SimpleParseFile(pyfile, real_filename, Py_file_input);
-	if (!py_file_node) {
-		PyErr_Print();
-		uwsgi_log("failed to parse file %s\n", real_filename);
-		exit(1);
-	}
-
-	fclose(pyfile);
-
 	py_compiled_node = (PyObject *) PyNode_Compile(py_file_node, real_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);
@@ -236,6 +295,15 @@ void init_uwsgi_vars() {
 		exit(1);
 	}
 	pysys_dict = PyModule_GetDict(pysys);
+
+#ifdef PYTHREE
+	// fix stdout and stderr
+	PyObject *new_stdprint = PyFile_NewStdPrinter(2);
+	PyDict_SetItemString(pysys_dict, "stdout", new_stdprint);
+	PyDict_SetItemString(pysys_dict, "__stdout__", new_stdprint);
+	PyDict_SetItemString(pysys_dict, "stderr", new_stdprint);
+	PyDict_SetItemString(pysys_dict, "__stderr__", new_stdprint);
+#endif
 	pypath = PyDict_GetItemString(pysys_dict, "path");
 	if (!pypath) {
 		PyErr_Print();
@@ -279,13 +347,16 @@ void init_uwsgi_vars() {
 		PyErr_Print();
 	}
 
-	for (i = 0; i < up.python_path_cnt; i++) {
-		if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(up.python_path[i])) != 0) {
+	struct uwsgi_string_list *uppp = up.python_path;
+	while(uppp) {
+		if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(uppp->value)) != 0) {
 			PyErr_Print();
 		}
 		else {
-			uwsgi_log("added %s to pythonpath.\n", up.python_path[i]);
+			uwsgi_log("added %s to pythonpath.\n", uppp->value);
 		}
+
+		uppp = uppp->next;
 	}
 
 	for (i = 0; i < up.pymodule_alias_cnt; i++) {
@@ -309,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
@@ -372,6 +447,25 @@ 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);
+	}
+
 	if (uwsgi.mode) {
 		if (PyDict_SetItemString(up.embedded_dict, "mode", PyString_FromString(uwsgi.mode))) {
 			PyErr_Print();
@@ -407,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);
@@ -419,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))) {
@@ -608,6 +674,9 @@ int uwsgi_python_magic(char *mountpoint, char *lazy) {
 
 int uwsgi_python_manage_options(int i, char *optarg) {
 
+	glob_t g;
+	int j;
+
 	switch (i) {
 	case 'w':
 		up.wsgi_config = optarg;
@@ -628,13 +697,20 @@ 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 (up.python_path_cnt < MAX_PYTHONPATH) {
-			up.python_path[up.python_path_cnt] = optarg;
-			up.python_path_cnt++;
+		if (glob(optarg, GLOB_MARK, NULL, &g)) {
+			uwsgi_string_new_list(&up.python_path, optarg);
 		}
 		else {
-			uwsgi_log("you can specify at most %d --pythonpath options\n", MAX_PYTHONPATH);
+			for (j = 0; j < (int) g.gl_pathc; j++) {
+				uwsgi_string_new_list(&up.python_path, g.gl_pathv[j]);
+			}
 		}
 		return 1;
 	case LONG_ARGS_PYARGV:
@@ -654,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] != '/') {
@@ -663,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;
@@ -685,13 +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);
@@ -714,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);
 	}
@@ -728,6 +898,35 @@ void uwsgi_python_init_apps() {
 		init_uwsgi_app(LOADER_EVAL, up.eval, uwsgi.wsgi_req, up.main_thread);
 	}
 
+	if (uwsgi.profiler) {
+		if (!strcmp(uwsgi.profiler, "pycall")) {
+			PyEval_SetProfile(uwsgi_python_profiler_call, NULL);
+		}
+	}
+
+}
+
+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() {
@@ -749,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) {
@@ -795,6 +997,9 @@ int uwsgi_python_xml(char *node, char *content) {
 			uwsgi.wsgi_req->module_len = strlen(uwsgi.wsgi_req->module);
 			return init_uwsgi_app(LOADER_DYN, uwsgi.wsgi_req, uwsgi.wsgi_req, interpreter);
 		}
+		else {
+			return init_uwsgi_app(LOADER_UWSGI, content, uwsgi.wsgi_req, interpreter);
+		}
 		return 1;
 	}
 	else if (!strcmp("pyhome", node)) {
@@ -815,28 +1020,41 @@ void uwsgi_python_suspend(struct wsgi_request *wsgi_req) {
 
 	PyThreadState *tstate = PyThreadState_GET();
 
-	uwsgi_log("suspending python\n");
-	up.current_recursion_depth = tstate->recursion_depth;
-	up.current_frame = tstate->frame;
+	if (wsgi_req) {
+		up.current_recursion_depth[wsgi_req->async_id] = tstate->recursion_depth;
+		up.current_frame[wsgi_req->async_id] = tstate->frame;
+	}
+	else {
+		up.current_main_recursion_depth = tstate->recursion_depth;
+		up.current_main_frame = tstate->frame;
+	}
 
 }
 
 int uwsgi_python_signal_handler(uint8_t sig, void *handler) {
 
+	UWSGI_GET_GIL;
+
 	PyObject *args = PyTuple_New(1);
 	PyObject *ret;
 
 	if (!args)
-		return -1;
+		goto clear;
+
+	if (!handler) goto clear;
+
 
 	PyTuple_SetItem(args, 0, PyInt_FromLong(sig));
 
 	ret = python_call(handler, args, 0);
 
 	if (ret) {
+		UWSGI_RELEASE_GIL;
 		return 0;
 	}
 
+clear:
+	UWSGI_RELEASE_GIL;
 	return -1;
 }
 
@@ -884,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;
 }
 
@@ -929,15 +1170,26 @@ void uwsgi_python_resume(struct wsgi_request *wsgi_req) {
 
 	PyThreadState *tstate = PyThreadState_GET();
 
-	uwsgi_log("resuming python\n");
-	tstate->recursion_depth = up.current_recursion_depth;
-	tstate->frame = up.current_frame;
+	if (wsgi_req) {
+		tstate->recursion_depth = up.current_recursion_depth[wsgi_req->async_id];
+		tstate->frame = up.current_frame[wsgi_req->async_id];
+	}
+	else {
+		tstate->recursion_depth = up.current_main_recursion_depth;
+		tstate->frame = up.current_main_frame;
+	}
 
 }
 
+void uwsgi_python_fixup() {
+	// set hacky modifier 30
+	uwsgi.p[30] = uwsgi.p[0];
+}
+
 struct uwsgi_plugin python_plugin = {
 
 	.name = "python",
+	.alias = "python",
 	.modifier1 = 0,
 	.init = uwsgi_python_init,
 	.post_fork = uwsgi_python_post_fork,
@@ -948,6 +1200,9 @@ struct uwsgi_plugin python_plugin = {
 	.after_request = uwsgi_after_request_wsgi,
 	.init_apps = uwsgi_python_init_apps,
 
+	.fixup = uwsgi_python_fixup,
+	.master_fixup = uwsgi_python_master_fixup,
+
 	.mount_app = uwsgi_python_mount_app,
 
 	.enable_threads = uwsgi_python_enable_threads,
@@ -963,8 +1218,7 @@ struct uwsgi_plugin python_plugin = {
 	.rpc = uwsgi_python_rpc,
 
 	.spooler = uwsgi_python_spooler,
-	/*
-	   .help = uwsgi_python_help,
-	 */
+
+	.help = uwsgi_python_help,
 
 };

plugins/python/pyutils.c

@@ -5,7 +5,6 @@ extern struct uwsgi_python up;
 
 int manage_python_response(struct wsgi_request *wsgi_req) {
 	// use standard WSGI response parse
-	wsgi_req->switches++;
 	return uwsgi_response_subhandler_wsgi(wsgi_req);
 }
 
@@ -13,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,598 @@
+#include "uwsgi_python.h"
+
+#ifndef PYTHREE
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+
+
+struct _symimporter {
+	PyObject_HEAD;
+} uwsgi_symbol_importer_object;
+
+struct _symzipimporter {
+	PyObject_HEAD;
+	char *prefix;
+	PyObject *zip;
+        PyObject *items;
+} uwsgi_symbol_zip_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_py(char *prefix, char *name) {
+
+	char *base;
+	char *ptr;
+
+	if (prefix) {
+		if (prefix[strlen(prefix)-1] == '/') { 
+        		base = uwsgi_concat3(prefix, name, ".py");
+			ptr = base + strlen(prefix);
+		}
+		else {
+        		base = uwsgi_concat4(prefix, "/", name, ".py");
+			ptr = base + strlen(prefix) + 1;
+		}
+	}
+	else {
+        	base = uwsgi_concat2(name, ".py");
+		ptr = base;
+	}
+        while(*ptr != 0) {
+                if (*ptr == '.') {
+                        *ptr = '/';
+                }
+                ptr++;
+        }
+
+	// fix .py
+	ptr-=3;
+	*ptr = '.';
+        return base;
+}
+
+static char *name_to_init_py(char *prefix, char *name) {
+
+	char *base;
+	char *ptr;
+
+	if (prefix) {
+		if (prefix[strlen(prefix)-1] == '/') { 
+        		base = uwsgi_concat3(prefix, name, "/__init__.py");
+			ptr = base + strlen(prefix);
+		}
+		else {
+        		base = uwsgi_concat4(prefix, "/", name, "/__init__.py");
+			ptr = base + strlen(prefix) + 1;
+		}
+	}
+	else {
+        	base = uwsgi_concat2(name, "/__init__.py");
+		ptr = base;
+	}
+
+        while(*ptr != 0) {
+                if (*ptr == '.') {
+                        *ptr = '/';
+                }
+                ptr++;
+        }
+
+        // fix .py
+        ptr-=3;
+        *ptr = '.';
+
+        return base;
+}
+
+
+
+
+static char *name_to_symbol(char *name, char *what) {
+
+        char *symbol = uwsgi_concat4("_binary_", name, "_", what);
+        char *sym_ptr_start = dlsym(RTLD_DEFAULT, symbol);
+        free(symbol);
+        return sym_ptr_start;
+}
+
+
+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;
+}
+
+int py_list_has_string(PyObject *obj, char *name) {
+
+	Py_ssize_t i, len = PyList_Size(obj);
+	int found = 0;
+	for(i=0;i<len;i++) {
+		PyObject *current = PyList_GetItem(obj, i);
+		char *filename = PyString_AsString(current);
+		if (!strcmp(filename, name)) {
+			found = 1;
+			break;
+		}
+	}
+
+	return found;
+}
+
+static PyObject* symzipimporter_find_module(PyObject *self, PyObject *args) {
+
+	char *fullname;
+	PyObject *path = NULL;
+	struct _symzipimporter *this = (struct _symzipimporter *) self;
+
+	if (!PyArg_ParseTuple(args, "s|O:find_module", &fullname, &path)) {
+		return NULL;
+	}
+
+	char *filename = name_to_py(this->prefix, fullname);
+
+	if (py_list_has_string(this->items, filename)) {
+		free(filename);
+		return self;
+	}
+
+	PyErr_Clear();
+	free(filename);
+
+	filename = name_to_init_py(this->prefix, fullname);
+
+	if (py_list_has_string(this->items, filename)) {
+		free(filename);
+		return self;
+	}
+
+	PyErr_Clear();
+	free(filename);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject* symzipimporter_load_module(PyObject *self, PyObject *args) {
+
+	char *fullname;
+	char *modname;
+        struct _symzipimporter *this = (struct _symzipimporter *) self;
+
+        if (!PyArg_ParseTuple(args, "s:load_module", &fullname)) {
+                return NULL;
+        }
+
+        char *filename = name_to_py(this->prefix, fullname);
+
+        if (py_list_has_string(this->items, filename)) {
+		PyObject *mod = PyImport_AddModule(fullname);
+                if (!mod) goto clear;
+                PyObject *dict = PyModule_GetDict(mod);
+                if (!dict) goto clear;
+
+                PyDict_SetItemString(dict, "__loader__", self);
+
+                modname = uwsgi_concat2("symzip://", fullname);
+
+		PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
+                free(filename);
+                PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+                mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+                Py_DECREF(code);
+                Py_DECREF(source);
+                free(modname);
+                return mod;
+        }
+
+        PyErr_Clear();
+        free(filename);
+
+        filename = name_to_init_py(this->prefix, fullname);
+
+        if (py_list_has_string(this->items, filename)) {
+		PyObject *mod = PyImport_AddModule(fullname);
+                if (!mod) goto clear;
+                PyObject *dict = PyModule_GetDict(mod);
+                if (!dict) goto clear;
+
+                modname = uwsgi_concat2("symzip://", fullname);
+
+		PyObject *pkgpath = Py_BuildValue("[O]", PyString_FromString(modname));
+
+                PyDict_SetItemString(dict, "__path__", pkgpath);
+                PyDict_SetItemString(dict, "__loader__", self);
+
+
+                PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
+                free(filename);
+                PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+                mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+                Py_DECREF(code);
+                Py_DECREF(source);
+                free(modname);
+                return mod;
+        }
+
+clear:
+        PyErr_Clear();
+        free(filename);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+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 PyMethodDef symzipimporter_methods[] = {
+    {"find_module", symzipimporter_find_module, METH_VARARGS},
+    {"load_module", symzipimporter_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 */
+};
+
+static int
+symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
+{
+
+
+	char *name;
+	char *prefix = NULL;
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+        	return -1; 
+
+	// avoid GC !!!
+	name = uwsgi_concat2(name, "");
+
+	prefix = strchr(name, ':');
+	if (prefix) {
+		prefix[0] = 0;
+	}
+
+	char *code_start = name_to_symbol(name, "start");
+	if (!code_start) {
+		PyErr_Format(PyExc_ValueError, "unable to find symbol");
+		return -1;
+	}
+
+	char *code_end = name_to_symbol(name, "end");
+	if (!code_end) {
+		PyErr_Format(PyExc_ValueError, "unable to find symbol");
+		return -1;
+	}
+
+	PyObject *stringio = PyImport_ImportModule("StringIO");
+	if (!stringio) {
+		PyErr_Print();
+		return -1;
+	}
+
+	PyObject *stringio_dict = PyModule_GetDict(stringio);
+	if (!stringio_dict) {
+		PyErr_Print();
+		return -1;
+	}
+
+	PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
+	if (!stringio_stringio) {
+		PyErr_Print();
+		return -1;
+	}
+
+	PyObject *stringio_args = PyTuple_New(1);
+	PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(code_start, code_end-code_start));
+
+	PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+	if (!source_code) {
+		PyErr_Print();
+		return -1;
+	}
+
+	PyObject *zipfile = PyImport_ImportModule("zipfile");
+	if (!zipfile) {
+		PyErr_Print();
+		return -1;
+	}
+	
+	PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+        if (!zipfile_dict) {
+                PyErr_Print();
+                return -1;
+        }
+
+        PyObject *zipfile_zipfile = PyDict_GetItemString(zipfile_dict, "ZipFile");
+        if (!zipfile_zipfile) {
+                PyErr_Print();
+                return -1;
+        }
+
+        PyObject *zipfile_args = PyTuple_New(1);
+        PyTuple_SetItem(zipfile_args, 0, source_code);
+
+	self->zip = PyInstance_New(zipfile_zipfile, zipfile_args, NULL);
+        if (!self->zip) {
+                PyErr_Print();
+                return -1;
+        }
+
+	Py_INCREF(self->zip);
+
+	self->items = PyObject_CallMethod(self->zip, "namelist", NULL);
+        if (!self->items) {
+                PyErr_Print();
+                return -1;
+        }
+
+	Py_INCREF(self->items);
+
+	self->prefix = NULL;
+	if (prefix) {
+		self->prefix = prefix+1;
+		prefix[0] = ':';
+	}
+
+
+	return 0;
+}
+
+static PyTypeObject SymZipImporter_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "uwsgi.SymbolsZipImporter",
+    sizeof(struct _symzipimporter),
+    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 zip importer",                                          /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    symzipimporter_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 */
+    (initproc) symzipimporter_init,                 /* 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);
+	}
+
+	if (PyType_Ready(&SymZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols zip 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);
+	}
+
+	if (PyModule_AddObject(uwsgi_em, "SymbolsZipImporter",
+                           (PyObject *)&SymZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols zip importer object\n");
+		exit(1);
+	}
+
+
+        return 0;
+	
+}
+
+#endif

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)) {
@@ -181,6 +240,25 @@ PyObject *py_uwsgi_close(PyObject * self, PyObject * args) {
 
 }
 
+PyObject *py_uwsgi_add_cron(PyObject * self, PyObject * args) {
+
+	uint8_t uwsgi_signal;
+	int minute, hour, day, month, week;
+
+	if (!PyArg_ParseTuple(args, "Biiiii:add_cron", &uwsgi_signal, &minute, &hour, &day, &month, &week)) {
+                return NULL;
+        }
+
+	if (uwsgi_signal_add_cron(uwsgi_signal, minute, hour, day, month, week)) {
+		return PyErr_Format(PyExc_ValueError, "unable to add cron");
+	}
+
+	Py_INCREF(Py_True);
+	return Py_True;
+}
+
+	
+
 PyObject *py_uwsgi_add_timer(PyObject * self, PyObject * args) {
 
 	uint8_t uwsgi_signal;
@@ -290,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)
@@ -322,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 {
 
@@ -342,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;
 
@@ -362,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;
@@ -376,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)) {
-				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;
 			}
 		}
 
@@ -407,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);
@@ -432,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;
@@ -459,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()");
 	}
@@ -727,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;
 
@@ -751,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);
 		}
 	}
@@ -773,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);
@@ -794,16 +899,16 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 PyObject *py_uwsgi_async_sleep(PyObject * self, PyObject * args) {
 
 	float timeout;
-	time_t sec_timeout;
+	int sec_timeout;
 
 	if (!PyArg_ParseTuple(args, "f:async_sleep", &timeout)) {
 		return NULL;
 	}
 
-	sec_timeout = (time_t) timeout;
+	sec_timeout = (int) timeout;
 
 	if (sec_timeout > 0) {
-		async_set_timeout(uwsgi.wsgi_req, sec_timeout);
+		async_add_timeout(uwsgi.wsgi_req, sec_timeout);
 	}
 
 	return PyString_FromString("");
@@ -848,15 +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);
-		UWSGI_SET_LOCKING;
+	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;
@@ -864,13 +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);
-	UWSGI_UNSET_LOCKING;
 
 	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;
@@ -1110,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);
 
@@ -1130,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++) {
@@ -1145,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);
@@ -1175,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
 
@@ -1218,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;
@@ -1332,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])) {
+					if (!uwsgi_parse_packet(&multipoll[i], PyInt_AsLong(arg_timeout), &uh, &buffer[i], uwsgi_proto_uwsgi_parser)) {
 						goto megamulticlear;
 					}
 					else {
@@ -1347,6 +1547,7 @@ PyObject *py_uwsgi_send_multi_message(PyObject * self, PyObject * args) {
 					}
 				}
 			}
+*/
 		}
 	}
 
@@ -1538,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);
 			}
 		}
 
@@ -1641,8 +1841,6 @@ PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 	int modifier1 = 0;
 	int modifier2 = 0;
 
-	ssize_t ret;
-
 	char *encoded;
 	uint16_t esize = 0;
 
@@ -1657,14 +1855,14 @@ PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 	if (PyDict_Check(pyobj)) {
 		encoded = uwsgi_encode_pydict(pyobj, &esize);
 		if (esize > 0) {
-			UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
+			UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
 			free(encoded);
 		}
 	}
 	else if (PyString_Check(pyobj)) {
 		encoded = PyString_AsString(pyobj);
 		esize = PyString_Size(pyobj);
-		UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
+		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
 	}
 	else {
 		marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
@@ -1675,7 +1873,7 @@ PyObject *py_uwsgi_async_send_message(PyObject * self, PyObject * args) {
 
 		encoded = PyString_AsString(marshalled);
 		esize = PyString_Size(marshalled);
-		UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
+		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, -1, 0, 0);
 	}
 
       UWSGI_GET_GIL clear:
@@ -1785,8 +1983,6 @@ PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 	int fd = -1;
 	int cl = 0;
 
-	ssize_t ret;
-
 	int uwsgi_fd = -1;
 	char *encoded;
 	uint16_t esize = 0;
@@ -1815,14 +2011,14 @@ PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 	if (PyDict_Check(pyobj)) {
 		encoded = uwsgi_encode_pydict(pyobj, &esize);
 		if (esize > 0) {
-			UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
+			UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
 			free(encoded);
 		}
 	}
 	else if (PyString_Check(pyobj)) {
 		encoded = PyString_AsString(pyobj);
 		esize = PyString_Size(pyobj);
-		UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
+		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
 	}
 	else {
 		marshalled = PyMarshal_WriteObjectToString(pyobj, 1);
@@ -1833,7 +2029,7 @@ PyObject *py_uwsgi_send_message(PyObject * self, PyObject * args) {
 
 		encoded = PyString_AsString(marshalled);
 		esize = PyString_Size(marshalled);
-		UWSGI_RELEASE_GIL ret = uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
+		UWSGI_RELEASE_GIL uwsgi_send_message(uwsgi_fd, (uint8_t) modifier1, (uint8_t) modifier2, encoded, esize, fd, cl, timeout);
 	}
 
 	UWSGI_GET_GIL
@@ -1992,7 +2188,6 @@ PyObject *py_uwsgi_reload(PyObject * self, PyObject * args) {
 PyObject *py_uwsgi_set_blocking(PyObject * self, PyObject * args) {
 
 	if (uwsgi.master_process) {
-		uwsgi.workers[uwsgi.mywid].status |= UWSGI_STATUS_BLOCKING;
 		Py_INCREF(Py_True);
 		return Py_True;
 	}
@@ -2068,7 +2263,7 @@ PyObject *py_uwsgi_parse_file(PyObject * self, PyObject * args) {
 
 	fd = open(filename, O_RDONLY);
 	if (fd < 0) {
-		uwsgi_error("open()");
+		uwsgi_error_open(filename);
 		goto clear;
 	}
 
@@ -2162,7 +2357,6 @@ PyObject *py_uwsgi_parse_file(PyObject * self, PyObject * args) {
 PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 
 	pid_t grunt_pid;
-	int i;
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 
 	if (uwsgi.grunt) {
@@ -2179,9 +2373,7 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 		goto clear;
 	}
 	else if (grunt_pid == 0) {
-		for (i = 0; i < uwsgi.sockets_cnt; i++) {
-			close(uwsgi.sockets[i].fd);
-		}
+		uwsgi_close_all_sockets();
 		// create a new session
 		setsid();
 		// exit on SIGPIPE
@@ -2193,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);
@@ -2200,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);
@@ -2210,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
@@ -2223,7 +2426,7 @@ PyObject *py_uwsgi_suspend(PyObject * self, PyObject * args) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 
-	uwsgi.schedule_to_main(wsgi_req);
+	if (uwsgi.schedule_to_main) uwsgi.schedule_to_main(wsgi_req);
 
 	Py_INCREF(Py_True);
 	return Py_True;
@@ -2258,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);
 			}
@@ -2329,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, ""},
@@ -2339,10 +2543,12 @@ 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, ""},
 	{"add_rb_timer", py_uwsgi_add_rb_timer, METH_VARARGS, ""},
+	{"add_cron", py_uwsgi_add_cron, METH_VARARGS, ""},
 
 	{"register_rpc", py_uwsgi_register_rpc, METH_VARARGS, ""},
 	{"rpc", py_uwsgi_rpc, METH_VARARGS, ""},
@@ -2384,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},
@@ -2481,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);
@@ -2508,7 +2716,6 @@ PyObject *py_uwsgi_queue_push(PyObject * self, PyObject * args) {
         }
 	
 	if (uwsgi.queue_size) {
-		uwsgi_log("locking queue\n");
                 uwsgi_wlock(uwsgi.queue_lock);
                 if (uwsgi_queue_push(message, msglen)) {
 			Py_INCREF(Py_True);
@@ -2519,7 +2726,6 @@ PyObject *py_uwsgi_queue_push(PyObject * self, PyObject * args) {
                         res = Py_None;
                 }
                 uwsgi_rwunlock(uwsgi.queue_lock);
-		uwsgi_log("unlocked queue\n");
                 return res;
         }
 
@@ -2591,10 +2797,61 @@ PyObject *py_uwsgi_queue_get(PyObject * self, PyObject * args) {
 	return Py_None;
 }
 
+PyObject *py_uwsgi_queue_last(PyObject * self, PyObject * args) {
+
+        long num = 0;
+        uint64_t size = 0;
+        char *message;
+        PyObject *res, *zero;
+	uint64_t base;
+
+        if (!PyArg_ParseTuple(args, "l:queue_last", &num)) {
+                return NULL;
+        }
+
+        if (uwsgi.queue_size) {
+		res = PyList_New(0);
+                uwsgi_rlock(uwsgi.queue_lock);
+		if (uwsgi.shared->queue_pos > 0) {
+			base = uwsgi.shared->queue_pos-1;
+		}
+		else {
+			base = uwsgi.queue_size-1;
+		}
+		if (num > (long)uwsgi.queue_size) num = uwsgi.queue_size;
+		while(num) {
+                	message = uwsgi_queue_get(base, &size);
+                	if (message && size) {
+                        	zero = PyString_FromStringAndSize(message, size);
+				PyList_Append(res, zero);
+				Py_DECREF(zero);
+                	}
+                	else {
+                		uwsgi_rwunlock(uwsgi.queue_lock);
+				return res;
+                	}
+			if (base > 0) {
+				base--;
+			}
+			else {
+				base = uwsgi.queue_size-1;
+			}
+			num--;
+		}
+                uwsgi_rwunlock(uwsgi.queue_lock);
+                return res;
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+}
+
+
 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;
@@ -2610,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;
 		}
 	}
@@ -2621,6 +2878,11 @@ PyObject *py_uwsgi_cache_get(PyObject * self, PyObject * args) {
 #endif
 		uwsgi_rlock(uwsgi.cache_lock);
 		value = uwsgi_cache_get(key, keylen, &valsize);
+		if (!value) {
+			uwsgi_rwunlock(uwsgi.cache_lock);
+			Py_INCREF(Py_None);
+			return Py_None;
+		}
 		res = PyString_FromStringAndSize(value, valsize);
 #ifdef UWSGI_DEBUG
 		gettimeofday(&tv2, NULL); 
@@ -2651,6 +2913,7 @@ static PyMethodDef uwsgi_cache_methods[] = {
 
 static PyMethodDef uwsgi_queue_methods[] = {
 	{"queue_get", py_uwsgi_queue_get, METH_VARARGS, ""},
+	{"queue_last", py_uwsgi_queue_last, METH_VARARGS, ""},
 	{"queue_push", py_uwsgi_queue_push, METH_VARARGS, ""},
 	{"queue_pull", py_uwsgi_queue_pull, METH_VARARGS, ""},
 	{"queue_slot", py_uwsgi_queue_slot, METH_VARARGS, ""},
@@ -2670,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

@@ -1,26 +1,33 @@
 #include "../../uwsgi.h"
 #include <Python.h>
 
+#include <frameobject.h>
 
-#define MAX_PYTHONPATH 64
 #define MAX_PYMODULE_ALIAS 64
+#define MAX_PYARGV 10
 
-#define LONG_ARGS_PYTHON_BASE      17000 + ((0 + 1) * 100)
+#define LONG_ARGS_PYTHON_BASE      17000 + ((0 + 1) * 1000)
 
 #define LONG_ARGS_PYTHONPATH            LONG_ARGS_PYTHON_BASE + 1
 #define LONG_ARGS_PASTE                 LONG_ARGS_PYTHON_BASE + 2
 #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
-
-#ifdef UWSGI_STACKLESS
-#include <stackless_api.h>
-#endif
+#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
 #endif
 
+#if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 7
+#define HAS_NOT_PyFrame_GetLineNumber 
+#endif
+
+#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 2
+#define HAS_NOT_PyFrame_GetLineNumber 
+#endif
+
 #if PY_MAJOR_VERSION > 2
 #define PYTHREE
 #endif
@@ -55,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
@@ -93,8 +104,9 @@ struct uwsgi_python {
 
 	char *test_module;
 
-	char *python_path[MAX_PYTHONPATH];
-	int python_path_cnt;
+	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 *);
@@ -110,8 +122,11 @@ struct uwsgi_python {
 	int ignore_script_name;
 	int catch_exceptions;
 
-	int current_recursion_depth;
-	struct _frame* current_frame;
+	int *current_recursion_depth;
+	struct _frame **current_frame;
+
+	int current_main_recursion_depth;
+	struct _frame *current_main_frame;
 
 	void (*swap_ts)(struct wsgi_request *, struct uwsgi_app *);
 	void (*reset_ts)(struct wsgi_request *, struct uwsgi_app *);
@@ -157,10 +172,6 @@ PyObject *py_eventfd_read(PyObject *, PyObject *);
 PyObject *py_eventfd_write(PyObject *, PyObject *);
 
 
-#ifdef UWSGI_STACKLESS
-PyObject *py_uwsgi_stackless(PyObject *, PyObject *);
-#endif
-
 int manage_python_response(struct wsgi_request *);
 int uwsgi_python_call(struct wsgi_request *, PyObject *, PyObject *);
 PyObject *python_call(PyObject *, PyObject *, int);
@@ -174,18 +185,6 @@ ssize_t uwsgi_do_sendfile(int, int, size_t, size_t, off_t*, int);
 PyObject *py_uwsgi_write(PyObject *, PyObject *);
 PyObject *py_uwsgi_spit(PyObject *, PyObject *);
 
-#ifdef UWSGI_STACKLESS
-struct stackless_req {
-	PyTaskletObject *tasklet;
-	struct wsgi_request *wsgi_req;
-	PyChannelObject *channel;
-};
-struct wsgi_request *find_request_by_tasklet(PyTaskletObject *);
-
-void stackless_init(void);
-void stackless_loop(void);
-#endif
-
 void init_pyargv(void);
 
 #ifdef UWSGI_WEB3
@@ -228,3 +227,13 @@ void threaded_swap_ts(struct wsgi_request *, struct uwsgi_app *);
 void simple_swap_ts(struct wsgi_request *, struct uwsgi_app *);
 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']
+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 = []
@@ -20,10 +20,12 @@ else:
 		os.environ['LD_RUN_PATH'] = "%s/lib" % sysconfig.PREFIX
 
 
-version = sys.version_info
-uver = "%d.%d" % (version[0], version[1])
-
-LIBS.append('-lpython' + uver)
+version = sysconfig.get_config_var('VERSION')
+try:
+    version = version + sys.abiflags
+except:
+    pass
+LIBS.append('-lpython' + version)
 
 #if str(PYLIB_PATH) != '':
 #                libs.insert(0,'-L' + PYLIB_PATH)

plugins/python/wsgi_handlers.c

@@ -6,20 +6,95 @@ extern struct uwsgi_python up;
 
 typedef struct uwsgi_Input {
         PyObject_HEAD
-	off_t pos;
+	char readline[1024];
+	size_t readline_size;
+	size_t readline_max_size;
+	size_t readline_pos;
+	size_t pos;
 	struct wsgi_request *wsgi_req;
 } uwsgi_Input;
 
-PyObject *uwsgi_Input_iter(PyObject * self) {
+PyObject *uwsgi_Input_iter(PyObject *self) {
         Py_INCREF(self);
         return self;
 }
 
-PyObject *uwsgi_Input_next(PyObject * self) {
+PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
+	size_t i;
+	ssize_t rlen;
+	struct wsgi_request *wsgi_req = self->wsgi_req;
+	PyObject *res;
 
-	PyErr_SetNone(PyExc_StopIteration);
+	char *ptr = self->readline;
+
+	if (uwsgi.post_buffering > 0) {
+		ptr = wsgi_req->post_buffering_buf;
+		self->readline_size = wsgi_req->post_cl;
+		if (!self->readline_pos) {
+			self->pos += self->readline_size;
+		}
+	}
+
+	if (self->readline_pos > 0 || uwsgi.post_buffering) {
+		for(i=self->readline_pos;i<self->readline_size;i++) {
+			if (ptr[i] == '\n') {
+				res = PyString_FromStringAndSize(ptr+self->readline_pos, (i-self->readline_pos)+1);
+				self->readline_pos = i+1;
+				if (self->readline_pos >= self->readline_size) self->readline_pos = 0;
+				return res;
+			}
+		}
+		res = PyString_FromStringAndSize(ptr + self->readline_pos, self->readline_size - self->readline_pos);
+		self->readline_pos = 0;
+		return res;
+	}
+
+
+	UWSGI_RELEASE_GIL;
+	if (uwsgi_waitfd(wsgi_req->poll.fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]) <= 0) {
+                UWSGI_GET_GIL
+                return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data");
+        }
+
+	if (self->readline_max_size > 0 && self->readline_max_size < 1024) {
+        	rlen = read(wsgi_req->poll.fd, self->readline, self->readline_max_size);
+	}
+	else {
+        	rlen = read(wsgi_req->poll.fd, self->readline, 1024);
+	}
+        if (rlen < 0) {
+                UWSGI_GET_GIL
+                return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
+        }
+
+	self->readline_size = rlen;
+	self->readline_pos = 0;
+        self->pos += rlen;
+
+	UWSGI_GET_GIL;
+
+	for(i=0;i<(size_t)rlen;i++) {
+		if (self->readline[i] == '\n') {
+			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;
+		}
+	}
+	self->readline_pos = 0;
+	return PyString_FromStringAndSize(self->readline, self->readline_size);
+	
+}
+
+PyObject *uwsgi_Input_next(PyObject* self) {
+
+	if (!((uwsgi_Input *)self)->wsgi_req->post_cl || ((size_t) ((uwsgi_Input *)self)->pos >= ((uwsgi_Input *)self)->wsgi_req->post_cl && !((uwsgi_Input *)self)->readline_pos)) {
+		PyErr_SetNone(PyExc_StopIteration);
+		return NULL;
+	}
+
+	return uwsgi_Input_getline((uwsgi_Input *)self);
 
-	return NULL;
 }
 
 static void uwsgi_Input_free(uwsgi_Input *self) {
@@ -29,10 +104,9 @@ static void uwsgi_Input_free(uwsgi_Input *self) {
 static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 
 	long len = 0;
-	size_t remains, chunk_size;
+	size_t remains, tmp_pos = 0;
 	ssize_t rlen;
 	char *tmp_buf;
-	int fd;
 	PyObject *res;
 
 	if (!PyArg_ParseTuple(args, "|l:read", &len)) {
@@ -40,62 +114,70 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 	}
 
 	// return empty string if no post_cl or pos >= post_cl
-	if (!self->wsgi_req->post_cl || (size_t) self->pos >= self->wsgi_req->post_cl) {
+	if ((!self->wsgi_req->post_cl || (size_t) self->pos >= self->wsgi_req->post_cl ) && !self->readline_pos) {
 		return PyString_FromString("");
 	}
 
-	if (uwsgi.post_buffering > 0) {
-		fd = -1;
-		if (self->wsgi_req->post_cl <= (size_t) uwsgi.post_buffering) {
-			fd = fileno((FILE *)self->wsgi_req->async_post);
+	// some residual data ?
+	if (self->readline_pos && self->readline_size) {
+		if (len > 0) {
+			if ((size_t) len < (self->readline_size - self->readline_pos)) {
+				res = PyString_FromStringAndSize(self->readline + self->readline_pos, len);
+				self->readline_pos+=len;
+				if (self->readline_pos >= self->readline_size) self->readline_pos = 0;
+				return res;	
+			}
 		}
+		self->readline_pos = 0;
+		return PyString_FromStringAndSize(self->readline + self->readline_pos, self->readline_size - self->readline_pos);
 	}
-	else {
-		fd = self->wsgi_req->poll.fd;
-	}
+
 	// return the whole input
-	if (len <= 0) {
-		remains = self->wsgi_req->post_cl;
-	}
-	else {
-		remains = len ;
-	}
+        if (len <= 0) {
+                remains = self->wsgi_req->post_cl;
+        }
+        else {
+                remains = len ;
+        }
 
 	if (remains + self->pos > self->wsgi_req->post_cl) {
-		remains = self->wsgi_req->post_cl - self->pos;
-	} 
+                remains = self->wsgi_req->post_cl - self->pos;
+        }
 
-	if (remains <= 0) {
-		return PyString_FromString("");
-	}
+        if (remains <= 0) {
+                return PyString_FromString("");
+        }
 
-	if (fd == -1) {
-		res = PyString_FromStringAndSize( self->wsgi_req->post_buffering_buf, remains);
-		self->pos += remains;	
+	if (uwsgi.post_buffering > 0) {
+		res = PyString_FromStringAndSize( self->wsgi_req->post_buffering_buf+self->pos, remains);
+		self->pos += remains;
 		return res;
 	}
 
-	chunk_size = remains;
+	UWSGI_RELEASE_GIL
+
 	tmp_buf = uwsgi_malloc(remains);	
+
 	while(remains) {
-		if (uwsgi_waitfd(fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]) <= 0) {
-			free(tmp_buf);
-			return PyErr_Format(PyExc_ValueError, "error waiting for wsgi.input data");
-		}
+		if (uwsgi_waitfd(self->wsgi_req->poll.fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]) <= 0) {
+                       	free(tmp_buf);
+                       	UWSGI_GET_GIL
+                       	return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data");
+               	}
 
-		rlen = read(fd, tmp_buf + self->pos, remains);
+		rlen = read(self->wsgi_req->poll.fd, tmp_buf+tmp_pos, remains);
 		if (rlen < 0) {
-			free(tmp_buf);
-			return PyErr_Format(PyExc_ValueError, "error reading wsgi.input data");
-		}
-
-		if (!rlen) break;
-
-		self->pos += rlen;
+                       	free(tmp_buf);
+                       	UWSGI_GET_GIL
+                       	return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
+               	}
+		tmp_pos += rlen;
 		remains -= rlen;
 	}
 
-	res = PyString_FromStringAndSize(tmp_buf, chunk_size);
+	UWSGI_GET_GIL
+	self->pos += tmp_pos;
+	res = PyString_FromStringAndSize(tmp_buf, tmp_pos);
 	free(tmp_buf);
 	return res;
 		
@@ -103,17 +185,40 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 
 static PyObject *uwsgi_Input_readline(uwsgi_Input *self, PyObject *args) {
 
-	return NULL;
+	if (!PyArg_ParseTuple(args, "|l:readline", &((uwsgi_Input *)self)->readline_max_size)) {
+                return NULL;
+        }
+
+	if (!((uwsgi_Input *)self)->wsgi_req->post_cl || ((size_t) ((uwsgi_Input *)self)->pos >= ((uwsgi_Input *)self)->wsgi_req->post_cl && !((uwsgi_Input *)self)->readline_pos)) {
+		return PyString_FromString("");
+	}
+	return uwsgi_Input_getline(self);
+
 }
 
 static PyObject *uwsgi_Input_readlines(uwsgi_Input *self, PyObject *args) {
 
-	return NULL;
+	PyObject *res;
+
+	if (!((uwsgi_Input *)self)->wsgi_req->post_cl || ((size_t) ((uwsgi_Input *)self)->pos >= ((uwsgi_Input *)self)->wsgi_req->post_cl && !((uwsgi_Input *)self)->readline_pos)) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	res = PyList_New(0);
+	while( ((size_t) ((uwsgi_Input *)self)->pos < ((uwsgi_Input *)self)->wsgi_req->post_cl || ((uwsgi_Input *)self)->readline_pos > 0)) {
+		PyObject *a_line = uwsgi_Input_getline(self);
+		PyList_Append(res, a_line);	
+		Py_DECREF(a_line);
+	}
+
+	return res;
 }
 
 static PyObject *uwsgi_Input_close(uwsgi_Input *self, PyObject *args) {
 
-	return NULL;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
 static PyMethodDef uwsgi_Input_methods[] = {
@@ -175,7 +280,7 @@ PyObject *py_uwsgi_write(PyObject * self, PyObject * args) {
 		content = PyString_AsString(data);
 		len = PyString_Size(data);
 		UWSGI_RELEASE_GIL
-			wsgi_req->response_size = write(wsgi_req->poll.fd, content, len);
+			wsgi_req->response_size = wsgi_req->socket->proto_write(wsgi_req, content, len);
 		UWSGI_GET_GIL
 	}
 
@@ -196,12 +301,7 @@ PyObject *py_eventfd_read(PyObject * self, PyObject * args) {
 	}
 
 	if (fd >= 0) {
-		wsgi_req->async_waiting_fd = fd;
-		wsgi_req->async_waiting_fd_type = ASYNC_IN;
-		wsgi_req->async_waiting_fd_monitored = 0;
-		if (timeout > 0) {
-			wsgi_req->async_timeout = time(NULL) + timeout;
-		}
+		async_add_fd_read(wsgi_req, fd, timeout);
 	}
 
 	return PyString_FromString("");
@@ -218,12 +318,7 @@ PyObject *py_eventfd_write(PyObject * self, PyObject * args) {
 	}
 
 	if (fd >= 0) {
-		wsgi_req->async_waiting_fd = fd;
-		wsgi_req->async_waiting_fd_type = ASYNC_OUT;
-		wsgi_req->async_waiting_fd_monitored = 0;
-		if (timeout > 0) {
-			wsgi_req->async_timeout = time(NULL) + timeout;
-		}
+		async_add_fd_write(wsgi_req, fd, timeout);
 	}
 
 	return PyString_FromString("");
@@ -243,19 +338,24 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	char *what;
 	int what_len;
 
-	PyObject *wsgi_socket;
-
-
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
 		// get rid of timeout
-		if (wsgi_req->async_timeout_expired) {
+		if (wsgi_req->async_timed_out) {
 			PyDict_SetItemString(wsgi_req->async_environ, "x-wsgiorg.fdevent.timeout", Py_True);
-			wsgi_req->async_timeout_expired = 0;
+			wsgi_req->async_timed_out = 0;
 		}
 		else {
 			PyDict_SetItemString(wsgi_req->async_environ, "x-wsgiorg.fdevent.timeout", Py_None);
 		}
+
+		if (wsgi_req->async_ready_fd) {
+			PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.ready_fd", PyInt_FromLong(wsgi_req->async_last_ready_fd));
+			wsgi_req->async_ready_fd = 0;
+		}
+		else {
+			PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.ready_fd", Py_None);
+		}
 		return manage_python_response(wsgi_req);
 	}
 #endif
@@ -268,19 +368,10 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 	if (uwsgi_parse_vars(wsgi_req)) {
-		uwsgi_log("Invalid WSGI request. skip.\n");
 		return -1;
 	}
 
 
-	if (uwsgi.limit_post) {
-		if (wsgi_req->post_cl > uwsgi.limit_post) {
-			uwsgi_log("Invalid (too big) CONTENT_LENGTH. skip.\n");
-			return -1;
-		}
-	}
-
-
 	if (!up.ignore_script_name) {
 
 		if (!wsgi_req->script_name)
@@ -308,22 +399,22 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 						|| wsgi_req->file_len > 0
 						|| wsgi_req->paste_len > 0
 				   ) {
-					// a bit of magic: 1-1 = 0 / 0-1 = -1
 					// this part must be heavy locked in threaded modes
 					if (uwsgi.threads > 1) {
 						pthread_mutex_lock(&up.lock_pyloaders);
 					}
+
 					UWSGI_GET_GIL
-						if (uwsgi.single_interpreter) {
-							wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, up.main_thread);
-						}
-						else {
-							wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, NULL);
-						}
+					if (uwsgi.single_interpreter) {
+						wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, up.main_thread);
+					}
+					else {
+						wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, NULL);
+					}
 					UWSGI_RELEASE_GIL
-						if (uwsgi.threads > 1) {
-							pthread_mutex_unlock(&up.lock_pyloaders);
-						}
+					if (uwsgi.threads > 1) {
+						pthread_mutex_unlock(&up.lock_pyloaders);
+					}
 				}
 			}
 		}
@@ -344,7 +435,7 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 			wsgi_req->app_id = uwsgi.default_app;
 		}
 		else {
-			internal_server_error(wsgi_req->poll.fd, "wsgi application not found");
+			internal_server_error(wsgi_req, "wsgi application not found");
 			goto clear2;
 		}
 
@@ -366,13 +457,14 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 	if (wsgi_req->protocol_len < 5) {
 		uwsgi_log( "INVALID PROTOCOL: %.*s\n", wsgi_req->protocol_len, wsgi_req->protocol);
-		internal_server_error(wsgi_req->poll.fd, "invalid HTTP protocol !!!");
+		internal_server_error(wsgi_req, "invalid HTTP protocol !!!");
 		goto clear;
 
 	}
+
 	if (strncmp(wsgi_req->protocol, "HTTP/", 5)) {
 		uwsgi_log( "INVALID PROTOCOL: %.*s\n", wsgi_req->protocol_len, wsgi_req->protocol);
-		internal_server_error(wsgi_req->poll.fd, "invalid HTTP protocol !!!");
+		internal_server_error(wsgi_req, "invalid HTTP protocol !!!");
 		goto clear;
 	}
 
@@ -398,8 +490,8 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 		uwsgi_debug("%.*s: %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
 #endif
 #ifdef PYTHREE
-		pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, "ignore");
-		pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, "ignore");
+		pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, NULL);
+		pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, NULL);
 #else
 		pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len);
 		pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
@@ -410,6 +502,7 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 	if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
+		wsgi_req->uh.modifier1 = 0;
 		pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
 		if (pydictkey) {
 			if (PyString_Check(pydictkey)) {
@@ -426,38 +519,25 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 
 
-	if (uwsgi.post_buffering > 0) {
-		UWSGI_RELEASE_GIL
-		// read to disk
-		if (wsgi_req->post_cl <= (size_t) uwsgi.post_buffering) {
-			if (!uwsgi_read_whole_body(wsgi_req, wsgi_req->post_buffering_buf, uwsgi.post_buffering_bufsize)) {
-				goto clear;
-			}
-		}
-		else {
-			if (!uwsgi_read_whole_body_in_mem(wsgi_req, wsgi_req->post_buffering_buf)) {
-				goto clear;
-			}
-		}
-		UWSGI_GET_GIL
+	// if async_post is mapped as a file, directly use it as wsgi.input
+	if (wsgi_req->async_post) {
+#ifdef PYTHREE
+                wsgi_req->async_input = PyFile_FromFd(fileno(wsgi_req->async_post), "wsgi_input", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "wsgi_input", "r", NULL);
+#endif
 	}
 	else {
-		wsgi_req->async_post = fdopen(wsgi_req->poll.fd, "r");
+		// create wsgi.input custom object
+		wsgi_req->async_input = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
+		((uwsgi_Input*)wsgi_req->async_input)->wsgi_req = wsgi_req; 
+		((uwsgi_Input*)wsgi_req->async_input)->pos = 0;
+		((uwsgi_Input*)wsgi_req->async_input)->readline_pos = 0;
+		((uwsgi_Input*)wsgi_req->async_input)->readline_max_size = 0;
+
 	}
 
-	if (!up.pep3333_input) {
-		wsgi_socket = PyFile_FromFile(wsgi_req->async_post, "wsgi_input", "r", NULL);
-		PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_socket);
-		Py_DECREF(wsgi_socket);
-	}
-	else {
-		wsgi_socket = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
-		((uwsgi_Input*)wsgi_socket)->wsgi_req = wsgi_req; 
-		((uwsgi_Input*)wsgi_socket)->pos = 0;
-		PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_socket);
-	}
-
-	
+	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
 
 	wsgi_req->async_result = wi->request_subhandler(wsgi_req, wi);
 
@@ -467,11 +547,15 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 
 		while (wi->response_subhandler(wsgi_req) != UWSGI_OK) {
-			wsgi_req->switches++;
 #ifdef UWSGI_ASYNC
 			if (uwsgi.async > 1) {
 				return UWSGI_AGAIN;
 			}
+			else {
+#endif
+				wsgi_req->switches++;
+#ifdef UWSGI_ASYNC
+			}
 #endif
 		}
 
@@ -482,9 +566,9 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 		// LOCK THIS PART
 
-		wsgi_req->response_size += write(wsgi_req->poll.fd, wsgi_req->protocol, wsgi_req->protocol_len);
-		wsgi_req->response_size += write(wsgi_req->poll.fd, " 500 Internal Server Error\r\n", 28 );
-		wsgi_req->response_size += write(wsgi_req->poll.fd, "Content-type: text/plain\r\n\r\n", 28 );
+		wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, wsgi_req->protocol, wsgi_req->protocol_len);
+		wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, " 500 Internal Server Error\r\n", 28 );
+		wsgi_req->response_size += wsgi_req->socket->proto_write(wsgi_req, "Content-type: text/plain\r\n\r\n", 28 );
 		wsgi_req->header_cnt = 1;
 
 		/*
@@ -513,9 +597,6 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 		close(tmp_stderr);
 	}
 
-	if (up.pep3333_input) {
-		Py_DECREF(wsgi_socket);
-	}
 clear:
 
 	up.reset_ts(wsgi_req, wi);
@@ -528,7 +609,6 @@ clear2:
 
 void uwsgi_after_request_wsgi(struct wsgi_request *wsgi_req) {
 
-
 	if (uwsgi.shared->options[UWSGI_OPTION_LOGGING] || wsgi_req->log_this) {
 		log_request(wsgi_req);
 	}

plugins/python/wsgi_headers.c

@@ -13,23 +13,36 @@ 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();
 
 	int base = 0;
-	int shift = 0;
 
-	// use writev()
+	// this must be done before headers management
+	if (PyTuple_Size(args) > 2) {
+		exc_info = PyTuple_GetItem(args, 2);
+		if (exc_info && exc_info != Py_None) {
+			PyObject *exc_type = PyTuple_GetItem(exc_info, 0);	
+			PyObject *exc_val = PyTuple_GetItem(exc_info, 1);
+			PyObject *exc_tb = PyTuple_GetItem(exc_info, 2);
 
-	// is a Web3 response ?
-	/*
-	   if (PyTuple_Size(args) == 3) {
-	   shift = 0;
-	   }
-	   */
+			if (!exc_type || !exc_val || !exc_tb) {
+				PyErr_Print();
+				goto clear;
+			}
 
-	head = PyTuple_GetItem(args, 0+shift);
+			Py_INCREF(exc_type);
+			Py_INCREF(exc_val);
+			Py_INCREF(exc_tb);
+			// in this way, error will be reported to the log
+			PyErr_Restore(exc_type, exc_val, exc_tb);
+
+			goto clear;	
+		}
+	}
+
+	head = PyTuple_GetItem(args, 0);
 	if (!head) {
 		goto clear;
 	}
@@ -56,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);
@@ -67,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 = atoi(wsgi_req->hvec[2].iov_base);
+		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);
@@ -86,26 +94,21 @@ 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 = atoi(wsgi_req->hvec[1].iov_base);
+		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);
+	if (!headers) goto clear;
+
 
-	headers = PyTuple_GetItem(args, 1+shift);
-	if (!headers) {
-		goto clear;
-	}
 	if (!PyList_Check(headers)) {
 		uwsgi_log( "http headers must be in a python list\n");
 		goto clear;
 	}
 	wsgi_req->header_cnt = PyList_Size(headers);
 
-
-
 	if (wsgi_req->header_cnt > uwsgi.max_vars) {
 		wsgi_req->header_cnt = uwsgi.max_vars;
 	}
@@ -135,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);
@@ -147,34 +148,67 @@ 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 = writev(wsgi_req->poll.fd, wsgi_req->hvec, j + 1);
+		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);
 
-
 	return up.wsgi_writeout;
 
 clear:

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);
@@ -124,7 +128,7 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 
 	// return or yield ?
 	if (PyString_Check((PyObject *)wsgi_req->async_result)) {
-		if ((wsize = write(wsgi_req->poll.fd, PyString_AsString(wsgi_req->async_result), PyString_Size(wsgi_req->async_result))) < 0) {
+		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(wsgi_req->async_result), PyString_Size(wsgi_req->async_result))) < 0) {
 			uwsgi_error("write()");
 			goto clear;
 		}
@@ -185,7 +189,7 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 
 
 	if (PyString_Check(pychunk)) {
-		if ((wsize = write(wsgi_req->poll.fd, PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
+		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
 			uwsgi_error("write()");
 			Py_DECREF(pychunk);
 			goto clear;
@@ -211,32 +215,17 @@ clear:
 	if (wsgi_req->sendfile_fd != -1) {
 		Py_DECREF((PyObject *)wsgi_req->async_sendfile);
 	}
+	if (wsgi_req->async_input) {
+		Py_DECREF((PyObject *)wsgi_req->async_input);
+	}
 	if (wsgi_req->async_environ) {
 		PyDict_Clear(wsgi_req->async_environ);
 	}
-	if (wsgi_req->async_post && !wsgi_req->fd_closed) {
-		fclose(wsgi_req->async_post);
-		if (!uwsgi.post_buffering || wsgi_req->post_cl <= (size_t) uwsgi.post_buffering) {
-			wsgi_req->fd_closed = 1;
-		}
-	}
 	Py_XDECREF((PyObject *)wsgi_req->async_placeholder);
 clear2:
 	Py_DECREF((PyObject *)wsgi_req->async_result);
 	PyErr_Clear();
 
-#ifdef UWSGI_DEBUG
-	if (wsgi_req->async_placeholder) {
-		uwsgi_debug("wsgi_req->async_placeholder: %d\n", ((PyObject *)wsgi_req->async_placeholder)->ob_refcnt);
-	}
-	if (wsgi_req->async_result) {
-		uwsgi_debug("wsgi_req->async_result: %d\n", ((PyObject *)wsgi_req->async_result)->ob_refcnt);
-	}
-	if (wsgi_req->async_app) {
-		uwsgi_debug("wsgi_req->async_app: %d\n", ((PyObject *)wsgi_req->async_app)->ob_refcnt);
-	}
-#endif
-
 	UWSGI_RELEASE_GIL
 	return UWSGI_OK;
 }

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'])
+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'])
+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'])
+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'])
+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/python30/uwsgiplugin.py

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

plugins/python31/uwsgiplugin.py

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