--locks

.hgignore

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

.hgtags

@@ -20,3 +20,15 @@ d9b9b540f7dce8cb05d2e61ca8b4d75f2ea25f62 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
+f4d3c4dcd7a63e21fcc9d8d567374c69935178bd 0.9.8.3
+6945ee03c7ea95eb19217ef1e1fb17d9ae26adbc 0.9.9-beta1
+fb168b0b86169219aa9b8e40f0caa6297cf34dbc 0.9.9-rc1
+6aa667612019fcff8e68af9469f73aff6fa378a8 0.9.9-rc2
+376ffd8f190623e5e2521fe9fa64bf03c31e71be 0.9.9

CONTRIBUTORS

@@ -0,0 +1,16 @@
+- 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
+Corey Farwell
+Charles Duffy

ChangeLog

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

Makefile

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

apache2/mod_uwsgi.c

@@ -51,7 +51,6 @@ LoadModule uwsgi_module <path_of_apache_modules>/mod_uwsgi.so
 #include <fcntl.h>
 
 
-#define MAX_VARS 64
 #define DEFAULT_SOCK "/tmp/uwsgi.sock"
 
 typedef struct {
@@ -73,6 +72,7 @@ typedef struct {
 	char script_name[256];
 	char scheme[9];
 	int cgi_mode ;
+	int max_vars;
 } uwsgi_cfg;
 
 module AP_MODULE_DECLARE_DATA uwsgi_module;
@@ -83,8 +83,18 @@ static uint16_t uwsgi_swap16(uint16_t x) {
 }
 #endif
 
-static int uwsgi_add_var(struct iovec *vec, int i, char *key, char *value, uint16_t *pkt_size) {
+static int uwsgi_add_var(struct iovec *vec, int i, request_rec *r, char *key, char *value, uint16_t *pkt_size) {
 
+	uwsgi_cfg *c = ap_get_module_config(r->per_dir_config, &uwsgi_module);
+
+#if APR_IS_BIGENDIAN
+	if (i+6 > c->max_vars) {
+#else
+	if (i+4 > c->max_vars) {
+#endif
+		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: max number of uwsgi variables reached. consider increasing it with uWSGImaxVars directive");
+		return i;
+	}
 
 #if APR_IS_BIGENDIAN
 	char *ptr;
@@ -150,6 +160,8 @@ static void *uwsgi_server_config(apr_pool_t *p, server_rec *s) {
 	c->modifier1 = 0 ;
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
+	c->max_vars = 128;
+	c->script_name[0] = 0;
 
 	return c;
 }
@@ -164,6 +176,13 @@ static void *uwsgi_dir_config(apr_pool_t *p, char *dir) {
 	c->modifier1 = 0 ;
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
+	c->max_vars = 128;
+	c->script_name[0] = 0;
+	if (dir) {
+		if (strcmp(dir, "/")) {
+			strncpy(c->script_name, dir, 255);
+		}
+	}
 
 	return c;
 }
@@ -243,11 +262,8 @@ static int uwsgi_handler(request_rec *r) {
 
 	uwsgi_cfg *c = ap_get_module_config(r->per_dir_config, &uwsgi_module);
 
-#if APR_IS_BIGENDIAN
-	struct iovec uwsgi_vars[(MAX_VARS*6)+1] ;
-#else
-	struct iovec uwsgi_vars[(MAX_VARS*4)+1] ;
-#endif
+	struct iovec *uwsgi_vars;
+
 	int vecptr = 1 ;
 	char pkt_header[4];
 	uint16_t pkt_size = 0;
@@ -315,68 +331,49 @@ static int uwsgi_handler(request_rec *r) {
 	}
 
 
+#if APR_IS_BIGENDIAN
+        uwsgi_vars = malloc(sizeof(struct iovec) * (c->max_vars*6)+1);
+#else
+        uwsgi_vars = malloc(sizeof(struct iovec) * (c->max_vars*4)+1);
+#endif
 		
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REQUEST_METHOD", (char *) r->method, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "QUERY_STRING", r->args ? r->args : "", &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_NAME", (char *) ap_get_server_name(r), &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_PORT", apr_psprintf(r->pool, "%u",ap_get_server_port(r)), &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_PROTOCOL", r->protocol, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REQUEST_URI", r->unparsed_uri, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REMOTE_ADDR", r->connection->remote_ip, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REMOTE_USER", r->user ? r->user : "", &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REQUEST_METHOD", (char *) r->method, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "QUERY_STRING", r->args ? r->args : "", &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_NAME", (char *) ap_get_server_name(r), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_PORT", apr_psprintf(r->pool, "%u",ap_get_server_port(r)), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_PROTOCOL", r->protocol, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REQUEST_URI", r->unparsed_uri, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REMOTE_ADDR", r->connection->remote_ip, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REMOTE_USER", r->user ? r->user : "", &pkt_size) ;
 	if (r->user) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "AUTH_TYPE", (char *) ap_auth_type(r), &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "AUTH_TYPE", (char *) ap_auth_type(r), &pkt_size) ;
 	}
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "DOCUMENT_ROOT", (char *) ap_document_root(r), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "DOCUMENT_ROOT", (char *) ap_document_root(r), &pkt_size) ;
 
 	if (c->scheme[0] != 0) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "UWSGI_SCHEME", c->scheme, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "UWSGI_SCHEME", c->scheme, &pkt_size) ;
 	}
 
-	if (c->script_name[0] == '/') {
-		if (c->script_name[1] == 0) {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", c->script_name, &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
-		}
+	if (c->script_name[0] != 0) {
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", c->script_name, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
 	}
 	else {
-		if (r->path_info) {
-			if (strlen(r->path_info) <= 0) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-			}
-			else {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", apr_pstrndup(r->pool, r->uri, (strlen(r->uri) - strlen(r->path_info) )) , &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->path_info, &pkt_size) ;
-			}
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-		}
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
 	}
 
 
 	headers = apr_table_elts(r->headers_in);
 	h = (apr_table_entry_t *) headers->elts;
 
-	// check for max vars (a bit ugly)
-	cnt = headers->nelts ;
-	if (cnt + 11 > MAX_VARS) {
-		cnt = MAX_VARS -11;
-	}
-
-	for(i=0;i< cnt;i++) {
+	for(i=0;i< headers->nelts;i++) {
 		if (h[i].key){
 			if (!strcasecmp(h[i].key, "Content-Type")) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "CONTENT_TYPE", h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "CONTENT_TYPE", h[i].val, &pkt_size) ;
 			}
 			else if (!strcasecmp(h[i].key, "Content-Length")) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "CONTENT_LENGTH", h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "CONTENT_LENGTH", h[i].val, &pkt_size) ;
 			}
 			else {
 				penv = apr_pstrcat(r->pool, "HTTP_", h[i].key, NULL);
@@ -388,7 +385,7 @@ static int uwsgi_handler(request_rec *r) {
 						*cp = toupper(*cp);
 					}
 				}
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, penv, h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, penv, h[i].val, &pkt_size) ;
 			}
 		}
 	}
@@ -397,7 +394,7 @@ static int uwsgi_handler(request_rec *r) {
 	headers = apr_table_elts(r->subprocess_env);
 	h = (apr_table_entry_t*) headers->elts;
 	for (i = 0; i < headers->nelts; ++i) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, h[i].key, h[i].val, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, h[i].key, h[i].val, &pkt_size) ;
 	}	
 	
 
@@ -418,11 +415,13 @@ static int uwsgi_handler(request_rec *r) {
 	if (cnt < 0) {
 		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: writev() %s", strerror(errno));
 		close(uwsgi_poll.fd);
+		free(uwsgi_vars);
 		return HTTP_INTERNAL_SERVER_ERROR;
 	}
 	else if (cnt != pkt_size+4) {
 		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: writev() returned wrong size");
 		close(uwsgi_poll.fd);
+		free(uwsgi_vars);
 		return HTTP_INTERNAL_SERVER_ERROR;
 	}
 
@@ -434,6 +433,7 @@ static int uwsgi_handler(request_rec *r) {
 			if (cnt < 0) {
 				ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: read() client block failed !");
 				close(uwsgi_poll.fd);
+				free(uwsgi_vars);
 				return HTTP_INTERNAL_SERVER_ERROR;
 			}
 		}
@@ -458,6 +458,7 @@ static int uwsgi_handler(request_rec *r) {
 		if (cnt == 0) {
 			ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: recv() timeout");
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 		else if (cnt > 0) {
@@ -467,6 +468,7 @@ static int uwsgi_handler(request_rec *r) {
 					if (errno != ECONNRESET) {
 						ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: recv() %s", strerror(errno));
 						apr_brigade_destroy(bb);
+						free(uwsgi_vars);
 						return HTTP_INTERNAL_SERVER_ERROR;
 					}
 					else {
@@ -489,6 +491,7 @@ static int uwsgi_handler(request_rec *r) {
 					if (r->connection->aborted) { 
 						close(uwsgi_poll.fd);
 						apr_brigade_destroy(bb);
+						free(uwsgi_vars);
 						return HTTP_INTERNAL_SERVER_ERROR;
 					}
 					apr_brigade_write(bb, NULL, NULL, buf, cnt);
@@ -508,6 +511,7 @@ static int uwsgi_handler(request_rec *r) {
 			ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: poll() %s", strerror(errno));
 			close(uwsgi_poll.fd);
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 	}
@@ -521,6 +525,7 @@ static int uwsgi_handler(request_rec *r) {
 
 	if (!c->cgi_mode) {
 		if (uwsgi_http_status_read == 0) {
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 	}
@@ -528,11 +533,13 @@ static int uwsgi_handler(request_rec *r) {
 
 		if (hret = ap_scan_script_header_err_brigade(r, bb, NULL)) {
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return hret;
 		}
 	}
 
 
+	free(uwsgi_vars);
 	return ap_pass_brigade(r->output_filters, bb) ;
 }
 
@@ -564,6 +571,22 @@ static const char * cmd_uwsgi_force_wsgi_scheme(cmd_parms *cmd, void *cfg, const
 
 }
 
+static const char *cmd_uwsgi_max_vars(cmd_parms *cmd, void *cfg, const char *value) {
+	uwsgi_cfg *c ;
+        int val ;
+
+        if (cfg) {
+                c = cfg ;
+        }
+        else {
+                c = ap_get_module_config(cmd->server->module_config, &uwsgi_module);
+        }
+
+        c->max_vars = atoi(value);
+
+        return NULL;
+}
+
 static const char * cmd_uwsgi_modifier1(cmd_parms *cmd, void *cfg, const char *value) {
 
         uwsgi_cfg *c ;
@@ -707,6 +730,7 @@ static const command_rec uwsgi_cmds[] = {
 	AP_INIT_TAKE1("uWSGIforceScriptName", cmd_uwsgi_force_script_name, NULL, ACCESS_CONF, "Fix for PATH_INFO/SCRIPT_NAME when the location has filesystem correspondence"),	
 	AP_INIT_TAKE1("uWSGIforceCGImode", cmd_uwsgi_force_cgi_mode, NULL, ACCESS_CONF, "Force uWSGI CGI mode for perfect integration with apache filter"),	
 	AP_INIT_TAKE1("uWSGIforceWSGIscheme", cmd_uwsgi_force_wsgi_scheme, NULL, ACCESS_CONF, "Force the WSGI scheme var (set by default to \"http\")"),	
+	AP_INIT_TAKE1("uWSGImaxVars", cmd_uwsgi_max_vars, NULL, ACCESS_CONF, "Set the maximum allowed number of uwsgi variables (default 128)"),	
 	{NULL}
 };
 

async.c

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

attach.py

@@ -0,0 +1,13 @@
+import struct
+import sys
+import os
+
+filename = sys.argv[1]
+
+size = os.path.getsize(filename)
+
+f = open(filename, 'r')
+print(f.read())
+f.close()
+
+print(struct.pack("<Q", size))

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

bootstrap4.py

@@ -0,0 +1,4 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.ZipImporter("data://0"))

bootstrap5.py

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

build/README

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

buildconf/default.ini

@@ -25,14 +25,20 @@ yaml_implementation = auto
 malloc_implementation = libc
 plugins =
 bin_name = uwsgi
+append_version =
 plugin_dir = .
 embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, ugreen
+as_shared_library = false
 
 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/gevent.ini

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

buildconf/lib.ini

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

buildconf/pylua.ini

@@ -1,7 +1,3 @@
 [uwsgi]
 inherit = default
 embedded_plugins = +,lua
-
-[python]
-paste = true
-web3 = true

buildconf/pypy.ini

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

buildconf/pyuwsgi.ini

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

buildconf/rack.ini

@@ -1,3 +1,3 @@
 [uwsgi]
 inherit = default
-embedded_plugins = rack, ping, nagios, rpc
+embedded_plugins = rack, ping, cache, nagios, rpc, fastrouter, http, ugreen

buildconf/unbit.ini

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

buildconf/unbitstaff.ini

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

cache.c

@@ -8,7 +8,7 @@ void uwsgi_init_cache() {
 	if (!uwsgi.cache_blocksize)
                         uwsgi.cache_blocksize = UMAX16;
 
-                if (uwsgi.cache_blocksize % uwsgi.page_size != 0) {
+                if ((uwsgi.cache_blocksize * uwsgi.cache_max_items) % uwsgi.page_size != 0) {
                         uwsgi_log("invalid cache blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.cache_blocksize, uwsgi.page_size);
                         exit(1);
                 }
@@ -131,19 +131,19 @@ 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;
 	struct uwsgi_subscriber *usub, nusub;
 	int found = 0;
 	int i;
-	
-	ptr = uwsgi_dict_get(udict, key, keylen, &vallen);
+
+	ptr = uwsgi_dict_get(udict, usr->key, usr->keylen, &vallen);
 	if (ptr && vallen) {
 		usub = (struct uwsgi_subscriber *) ptr;
 		for(i=0;i<(int)usub->nodes;i++) {
-			if (!uwsgi_strncmp(usub->names[i].name, usub->names[i].len, address, address_len)) {
+			if (!uwsgi_strncmp(usub->names[i].name, usub->names[i].len, usr->address, usr->address_len)) {
 				found = 1;
 				break;
 			}
@@ -157,19 +157,29 @@ 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++;
 			}
+			uwsgi_log("[uwsgi-subscription] %.*s => new node: %.*s\n", usr->keylen, usr->key, usr->address_len, usr->address);
+			udict->count++;
 		}
 		return;
 	}
 	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].len = 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));
+		uwsgi_log("[uwsgi-subscription] new pool: %.*s\n", usr->keylen, usr->key);
+		uwsgi_log("[uwsgi-subscription] %.*s => new node: %.*s\n", usr->keylen, usr->key, usr->address_len, usr->address);
+		udict->count++;
 	}
 
 }
@@ -508,6 +518,16 @@ int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint
 			uci->prev = last_index;
 		}
 	}
+	else if (flags & UWSGI_CACHE_FLAG_UPDATE) {
+		uci = &uwsgi.cache_items[index] ;
+		if (expires) {
+			expires += time(NULL);
+			uci->expires = expires;
+		}
+		memcpy(uwsgi.cache+(index*uwsgi.cache_blocksize), val, vallen);
+		uci->valsize = vallen;
+		ret = 0;
+	}
 
 end:
 	return ret;
@@ -578,3 +598,125 @@ end:
         return ret;
 
 }
+
+/* THIS PART IS HEAVILY OPTIMIZED: PERFORMANCE NOT ELEGANCE !!! */
+
+void *cache_thread_loop(void *fd_ptr) {
+
+	int *fd_tmp = (int *) fd_ptr;
+	int fd = *fd_tmp;
+	int i;
+	ssize_t len;
+	char uwsgi_packet[UMAX16+4];
+	struct uwsgi_header *uh = (struct uwsgi_header *) uwsgi_packet;
+	char *val;
+	uint64_t vallen;
+	char *key;
+	uint16_t keylen;
+	struct pollfd ctl_poll;
+	char *watermark;
+	struct sockaddr_un ctl_sun;
+	socklen_t ctl_sun_len;
+
+	ctl_poll.events = POLLIN;
+
+	for(;;) {
+		ctl_sun_len = sizeof(struct sockaddr_un);
+		pthread_mutex_lock(&uwsgi.cache_server_lock);
+
+		ctl_poll.fd = accept(fd, (struct sockaddr *) &ctl_sun, &ctl_sun_len);
+
+		pthread_mutex_unlock(&uwsgi.cache_server_lock);
+
+		if (ctl_poll.fd < 0) {
+			uwsgi_error("cache accept()");
+			continue;
+		}
+		i = 0;
+		while(i < 4) {
+			len = poll(&ctl_poll, 1, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+			if (len <= 0) {
+				uwsgi_error("cache poll()");
+				goto clear;
+			}
+			len = read(ctl_poll.fd, uwsgi_packet+i, 4-i);
+			if (len < 0) {
+				uwsgi_error("cache read()");
+				goto clear;
+			}
+			i+=len;
+		}
+
+		if (uh->pktsize == 0) goto clear;
+
+		while(i < 4+uh->pktsize) {
+			len = poll(&ctl_poll, 1, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+			if (len <= 0) {
+				uwsgi_error("cache poll()");
+				goto clear;
+			}
+			len = read(ctl_poll.fd, uwsgi_packet+i, (4+uh->pktsize)-i);
+			if (len < 0) {
+				uwsgi_error("cache read()");
+				goto clear;
+			}
+			i+=len;
+		}
+
+		watermark = uwsgi_packet+4+uh->pktsize;
+
+		// get first parameter
+		memcpy(&keylen, uwsgi_packet+4, 2);
+#ifdef __BIG_ENDIAN__
+        	keylen = uwsgi_swap16(keylen);
+#endif
+		if (uwsgi_packet+6+keylen > watermark) goto clear;
+		key = uwsgi_packet+6+keylen+2;
+		memcpy(&keylen, key-2, 2);
+#ifdef __BIG_ENDIAN__
+        	keylen = uwsgi_swap16(keylen);
+#endif
+
+		if (key+keylen > watermark) goto clear;
+
+		val = uwsgi_cache_get(key, keylen, &vallen);
+                if (val && vallen > 0) {
+                	if (write(ctl_poll.fd, val, vallen) < 0) {
+				uwsgi_error("cache write()");
+			}
+		}
+
+clear:
+		close(ctl_poll.fd);
+	}
+
+	return NULL;
+}
+
+int uwsgi_cache_server(char *socket, int threads) {
+
+	int *fd = uwsgi_malloc(sizeof(int));
+	
+	int i;
+	pthread_t thread_id;
+        char *tcp_port = strchr(socket, ':');
+        if (tcp_port) {
+                *fd = bind_to_tcp(socket, uwsgi.listen_queue, tcp_port);
+        }
+        else {
+                *fd = bind_to_unix(socket, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+        }
+
+        pthread_mutex_init(&uwsgi.cache_server_lock, NULL);
+
+	if (threads < 1) threads = 1;
+
+	uwsgi_log("*** cache-optimized server enabled on fd %d (%d threads) ***\n", *fd, threads);
+
+	for(i=0;i<threads;i++) {
+		pthread_create(&thread_id, NULL, cache_thread_loop, (void *) fd);
+	}
+
+        return *fd;
+}
+

config17.ru

@@ -0,0 +1,25 @@
+require 'stringio'
+
+hello = proc do |signum|
+  puts "Hello i am signal #{signum}"
+end
+
+file_changed = proc do |signum| 
+  puts "/tmp has been modified"
+end
+
+UWSGI.register_signal(17, '', hello)
+UWSGI.register_signal(30, '', file_changed)
+
+UWSGI.add_rb_timer(17 , 2)
+UWSGI.add_timer(17 , 1)
+UWSGI.add_file_monitor(30 , '/tmp')
+
+puts UWSGI.signal_registered(1)
+puts UWSGI.signal_registered(17)
+
+run lambda { |env| 
+        puts env.inspect
+	UWSGI.signal(17)
+	[200, {'Content-Type'=>'text/plain'}, StringIO.new("Hello World!\n")] 
+}

contrib/spoolqueue/producer.py

@@ -0,0 +1,11 @@
+from tasksconsumer import enqueue
+
+def application(env, sr):
+
+    sr('200 OK', [('Content-Type','text/html')])
+
+    enqueue(queue='fast', pippo='pluto')
+
+    return "Task enqueued"
+
+

contrib/spoolqueue/tasks.py

@@ -0,0 +1,9 @@
+from tasksconsumer import *
+
+@queueconsumer('fast', 4)
+def fast_queue(arguments):
+    print "fast", arguments
+
+@queueconsumer('slow')
+def slow_queue(arguments):
+    print "foobar", arguments

contrib/spoolqueue/tasksconsumer.py

@@ -0,0 +1,44 @@
+from uwsgidecorators import *
+import Queue
+from threading import Thread
+
+queues = {}
+
+class queueconsumer(object):
+
+    def __init__(self, name, num=1, **kwargs):
+        self.name = name
+	self.num = num
+        self.queue = Queue.Queue()
+	self.threads = []
+	self.func = None
+	queues[self.name] = self
+
+
+    @staticmethod
+    def consumer(self):
+        while True:
+	    req = self.queue.get()
+            print req
+	    self.func(req)
+	    self.queue.task_done()
+
+    def __call__(self, f):
+        self.func = f
+	for i in range(self.num):
+	    t = Thread(target=self.consumer,args=(self,))	
+	    self.threads.append(t)
+	    t.daemon = True
+	    t.start()
+
+@spool
+def spooler_enqueuer(arguments):
+    if 'queue' in arguments:
+        queue = arguments['queue']
+        queues[queue].queue.put(arguments)
+    else:
+        raise Exception("You have to specify a queue name")
+
+
+def enqueue(*args, **kwargs):
+    return spooler_enqueuer.spool(*args, **kwargs)

contrib/upstart/uwsgi.conf

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

contrib/urack.rb

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

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

debug.ini

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

decoratortest.py

@@ -0,0 +1,133 @@
+#!./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 hello2():
+    return "[RPC] 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))
+        print(uwsgi.call('helloworld'))
+        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)))
+        print(uwsgi.call('helloworld'))
+        uwsgi.signal(100)
+        time.sleep(1)
+
+
+# spool a task after 5 seconds
+@spool
+def delayed_task(args):
+    print("*** I am a delayed spool job. It is %s [%s]***" % (time.asctime(), str(args)))
+    # 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)
+        if uwsgi.i_am_the_spooler():
+            print("Hello from a thread in the spooler")
+        else:
+            print("Hello from a thread in worker %d" % uwsgi.worker_id())
+
+@postfork
+def fork_happened():
+    print("fork() has been called [1]")
+
+@postfork
+def fork_happened2():
+    if uwsgi.i_am_the_spooler():
+        return
+    print("worker %d is waiting for signal 100..." % uwsgi.worker_id())
+    uwsgi.signal_wait(100)
+    print("worker %d received signal %d" % (uwsgi.worker_id(), uwsgi.signal_received()))
+    print("fork() has been called [2] wid: %d" % uwsgi.worker_id())
+
+@postfork
+@lock
+def locked_func():
+    print("starting locked function on worker %d" % uwsgi.worker_id())
+    for i in xrange(1, 5):
+        time.sleep(1)
+        print("[locked %d] waiting..." % uwsgi.worker_id())
+    print("done with locked function on worker %d" % uwsgi.worker_id())
+
+print(uwsgi.call('helloworld'))
+spool_filename = a_long_task.spool({'foo':'bar'}, hello='world')
+print("spool filename = %s" % spool_filename)
+an_infinite_task.spool(foo='bar', priority=3)
+when = int(time.time())+5
+print("scheduling a delayed task at %d" % when)
+delayed_task.spool(foo2='bar2', at=when)
+a_running_thread()
+a_running_thread_with_args("uWSGI")
+uwsgi_source_file = open('uwsgi.c','r')
+print(big_body_task.spool(priority=9,filename='uwsgi.c',body=uwsgi_source_file.read()))
+uwsgi_source_file.close()

django/uwsgi_admin/views.py

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

django/uwsgitemplate.py

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

emperor.c

@@ -6,33 +6,77 @@ extern struct uwsgi_server uwsgi;
 extern char **environ;
 
 int emperor_queue;
+char *emperor_absolute_dir;
+
+void emperor_send_stats(int);
 
 struct uwsgi_instance {
-	struct uwsgi_instance *ui_prev;
-	struct uwsgi_instance *ui_next;
+        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;
-	time_t last_loyal;
+        int status;
+        time_t born;
+        time_t last_mod;
+        time_t last_loyal;
 
-	uint64_t respawns;
-	int use_config;
+        uint64_t respawns;
+        int use_config;
 
-	int pipe[2];
-	int pipe_config[2];
+        int pipe[2];
+        int pipe_config[2];
 
-	char *config;
-	uint32_t config_len;
+        char *config;
+        uint32_t config_len;
 
-	int loyal;
+        int loyal;
+
+        int zerg;
+	
+	uid_t uid;
+	gid_t gid;
 };
 
+
 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;
@@ -79,8 +123,21 @@ void emperor_del(struct uwsgi_instance *c_ui) {
 		close(c_ui->pipe_config[0]);
 	}
 
+	if (uwsgi.vassals_stop_hook) {
+                        uwsgi_log("running vassal stop-hook: %s %s\n", uwsgi.vassals_stop_hook, c_ui->name);
+			if (setenv("UWSGI_VASSALS_DIR", emperor_absolute_dir, 1)) {
+                                uwsgi_error("setenv()");
+                        }
+                        int stop_hook_ret = uwsgi_run_command_and_wait(uwsgi.vassals_stop_hook, c_ui->name);
+                        uwsgi_log("%s stop-hook returned %d\n", c_ui->name, stop_hook_ret);
+                }
+
 	uwsgi_log("removed uwsgi instance %s\n", c_ui->name);
 
+	if (c_ui->zerg) {
+		uwsgi.emperor_broodlord_count--;
+	}
+
 	free(c_ui);
 
 }
@@ -117,7 +174,7 @@ void emperor_respawn(struct uwsgi_instance *c_ui, time_t mod) {
 	uwsgi_log("reload the uwsgi instance %s\n", c_ui->name);
 }
 
-void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
+void emperor_add(char *name, time_t born, char *config, uint32_t config_size, uid_t uid, gid_t gid) {
 
 	struct uwsgi_instance *c_ui = ui;
 	struct uwsgi_instance *n_ui = NULL;
@@ -126,8 +183,17 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	char *uef;
 	char **uenvs;
 	int counter;
+	char *colon = NULL;
+	int i;
 
-	sleep(1);
+	usleep(uwsgi.emperor_throttle*1000);
+
+	if (uwsgi.emperor_tyrant) {
+		if (uid == 0 || gid == 0) {
+			uwsgi_log("[emperor-tyrant] invalid permissions for file %s\n", name);
+			return;
+		}
+	}
 
 	while (c_ui->ui_next) {
 		c_ui = c_ui->ui_next;
@@ -147,8 +213,16 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	uwsgi_log("c_ui->ui_next = %p\n", c_ui->ui_next);
 #endif
 	n_ui->ui_prev = c_ui;
+
+	if (strchr(name,':')) {
+		n_ui->zerg = 1;
+		uwsgi.emperor_broodlord_count++;
+	}
+
 	memcpy(n_ui->name, name, strlen(name));
 	n_ui->born = born;
+	n_ui->uid = uid;
+	n_ui->gid = gid;
 	n_ui->last_mod = born;
 	// start without loyalty
 	n_ui->last_loyal = born;
@@ -193,7 +267,26 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	}
 	else {
 
+		if (uwsgi.emperor_tyrant) {
+			uwsgi_log("[emperor-tyrant] dropping privileges to %d %d for instance %s\n", (int) uid, (int) gid, name);
+			if (setgid(gid)) {
+                                uwsgi_error("setgid()");
+                                exit(1);
+                        }
+                        if (setgroups(0, NULL)) {
+                                uwsgi_error("setgroups()");
+                                exit(1);
+                        }
+
+                        if (setuid(uid)) {
+                                uwsgi_error("setuid()");
+                                exit(1);
+                        }
+
+		}
+
 		unsetenv("UWSGI_RELOADS");
+		unsetenv("NOTIFY_SOCKET");
 
 		uef = uwsgi_num2str(n_ui->pipe[1]);
 		if (setenv("UWSGI_EMPEROR_FD", uef, 1)) {
@@ -250,6 +343,13 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 		argv = uwsgi_malloc(sizeof(char *) * counter);
 		// set args
 		argv[0] = uwsgi.binary_path;
+
+		if (uwsgi.emperor_broodlord) {
+			colon = strchr(name, ':');
+			if (colon) {
+				colon[0] = 0;
+			}
+		}
 		if (!strcmp(name + (strlen(name) - 4), ".xml"))
 			argv[1] = "--xml";
 		if (!strcmp(name + (strlen(name) - 4), ".ini"))
@@ -260,6 +360,10 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			argv[1] = "--yaml";
 		if (!strcmp(name + (strlen(name) - 3), ".js"))
 			argv[1] = "--json";
+
+		if (colon) {
+			colon[0] = ':';
+		}
 		argv[2] = name;
 		counter = 3;
 		uct = uwsgi.vassals_templates;
@@ -270,6 +374,23 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 			uct = uct->next;
 		}
 		argv[counter] = NULL;
+
+		// close all of the unneded fd
+		for(i=3;i<sysconf(_SC_OPEN_MAX);i++) {
+			if (i != n_ui->pipe[1]) {
+				close(i);
+			}
+		}
+
+		if (uwsgi.vassals_start_hook) {
+			uwsgi_log("running vassal start-hook: %s %s\n", uwsgi.vassals_start_hook, n_ui->name);
+			if (setenv("UWSGI_VASSALS_DIR", emperor_absolute_dir, 1)) {
+				uwsgi_error("setenv()");
+			}
+			int start_hook_ret = uwsgi_run_command_and_wait(uwsgi.vassals_start_hook, n_ui->name);
+			uwsgi_log("%s start-hook returned %d\n", n_ui->name, start_hook_ret);
+		}
+
 		// start !!!
 		if (execvp(argv[0], argv)) {
 			uwsgi_error("execvp()");
@@ -309,8 +430,15 @@ void emperor_loop() {
 	void *events;
 	int nevents;
 	int interesting_fd;
+	char notification_message[64];
+
+	uwsgi.emperor_stats_fd = -1;
 
 	signal(SIGPIPE, SIG_IGN);
+	uwsgi_unix_signal(SIGINT, royal_death);
+        uwsgi_unix_signal(SIGTERM, royal_death);
+        uwsgi_unix_signal(SIGQUIT, royal_death);
+        uwsgi_unix_signal(SIGUSR1, emperor_stats);
 
 	memset(&ui_base, 0, sizeof(struct uwsgi_instance));
 
@@ -319,7 +447,29 @@ void emperor_loop() {
 
         events = event_queue_alloc(64);
 
-	uwsgi_log("*** starting uWSGI Emperor ***\n");
+	if (uwsgi.has_emperor) {
+		uwsgi_log("*** starting uWSGI sub-Emperor ***\n");
+	}
+	else {
+		uwsgi_log("*** starting uWSGI Emperor ***\n");
+	}
+
+	if (uwsgi.emperor_stats) {
+                char *tcp_port = strchr(uwsgi.emperor_stats, ':');
+                if (tcp_port) {
+                        // disable deferred accept for this socket
+                        int current_defer_accept = uwsgi.no_defer_accept;
+                        uwsgi.no_defer_accept = 1;
+                        uwsgi.emperor_stats_fd = bind_to_tcp(uwsgi.emperor_stats, uwsgi.listen_queue, tcp_port);
+                        uwsgi.no_defer_accept = current_defer_accept;
+                }
+                else {
+                        uwsgi.emperor_stats_fd = bind_to_unix(uwsgi.emperor_stats, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+                }
+
+                event_queue_add_fd_read(emperor_queue, uwsgi.emperor_stats_fd);
+                uwsgi_log("*** Emperor stats server enabled on %s fd: %d ***\n", uwsgi.emperor_stats, uwsgi.emperor_stats_fd);
+        }
 
 	amqp_port = strchr(uwsgi.emperor_dir, ':');
 
@@ -347,7 +497,7 @@ reconnect:
 		event_queue_add_fd_read(emperor_queue, amqp_fd);
 	}
 	else {
-		if (!glob(uwsgi.emperor_dir, GLOB_MARK, NULL, &g)) {
+		if (!glob(uwsgi.emperor_dir, GLOB_MARK|GLOB_NOCHECK, NULL, &g)) {
 			if (g.gl_pathc == 1 && g.gl_pathv[0][strlen(g.gl_pathv[0]) - 1] == '/') {
 				simple_mode = 1;
 				if (chdir(uwsgi.emperor_dir)) {
@@ -360,6 +510,7 @@ reconnect:
 			uwsgi_error("glob()");
 			exit(1);
 		}
+		emperor_absolute_dir = realpath(".", NULL);
 	}
 
 	ui = &ui_base;
@@ -388,6 +539,7 @@ reconnect:
 				
 				if (!config) {
 					uwsgi_log("problem with RabbitMQ server, trying reconnection...\n");
+					event_queue_del_fd(emperor_queue, amqp_fd, event_queue_read());
 					close(amqp_fd);
 					amqp_fd = -1;
 					goto reconnect;
@@ -407,6 +559,7 @@ reconnect:
 						ui_current->config = config;
 						ui_current->config_len = msgsize;
 						if (!msgsize) {
+							// SAFE
 							emperor_del(ui_current);
 						}
 						else {
@@ -415,7 +568,7 @@ reconnect:
                                         }
                                         else {
 						if (msgsize > 0) {
-                                                	emperor_add(config_file, time(NULL), config, msgsize);
+                                                	emperor_add(config_file, time(NULL), config, msgsize, 0, 0);
 						}
                                         }
 
@@ -452,19 +605,25 @@ reconnect:
 						emperor_respawn(ui_current, time(NULL));
 					}
 					else {
-						emperor_add(config_file, time(NULL), NULL, 0);
+						emperor_add(config_file, time(NULL), NULL, 0, 0, 0);
 					}
 
 					free(config_file);
 				}
 				}
 			}
+			else if (uwsgi.emperor_stats && uwsgi.emperor_stats_fd > -1) {
+                        	if (interesting_fd == uwsgi.emperor_stats_fd) {
+                                	emperor_send_stats(uwsgi.emperor_stats_fd);
+                                }
+                        }
 			else {
 				ui_current = emperor_get_by_fd(interesting_fd);
 				if (ui_current) {
 					char byte;
 					ssize_t rlen = read(interesting_fd, &byte, 1);
 					if (rlen <= 0) {
+						// SAFE
 						emperor_del(ui_current);
 					}
 					else {
@@ -474,10 +633,20 @@ reconnect:
 							
 							// TODO post-start hook
 						}
+						else if (byte == 22) {
+							emperor_stop(ui_current);
+						}
+						else if (byte == 30 && uwsgi.emperor_broodlord > 0 && uwsgi.emperor_broodlord_count < uwsgi.emperor_broodlord) {
+							uwsgi_log("[emperor] going in broodlord mode: launching zergs for %s\n", ui_current->name);
+							char *zerg_name = uwsgi_concat3(ui_current->name,":","zerg");
+							emperor_add(zerg_name, time(NULL), NULL, 0, ui_current->uid, ui_current->gid);
+							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);
 				}
 			}
@@ -507,20 +676,28 @@ reconnect:
 					ui_current = emperor_get(de->d_name);
 
 					if (ui_current) {
+						// check if uid or gid are changed, in such case, sotp the instance
+						if (uwsgi.emperor_tyrant) {
+							if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+								uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n"); 
+								emperor_stop(ui_current);	
+								continue;
+							}	
+						}
 						// check if mtime is changed and the uWSGI instance must be reloaded
 						if (st.st_mtime > ui_current->last_mod) {
 							emperor_respawn(ui_current, st.st_mtime);
 						}
 					}
 					else {
-						emperor_add(de->d_name, st.st_mtime, NULL, 0);
+						emperor_add(de->d_name, st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
 					}
 				}
 			}
 			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;
 			}
@@ -546,13 +723,21 @@ reconnect:
 					ui_current = emperor_get(g.gl_pathv[i]);
 
 					if (ui_current) {
+						// check if uid or gid are changed, in such case, sotp the instance
+                                                if (uwsgi.emperor_tyrant) {
+                                                        if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+                                                                uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n");
+                                                                emperor_stop(ui_current);
+                                                                continue;
+                                                        }
+                                                }
 						// check if mtime is changed and the uWSGI instance must be reloaded
 						if (st.st_mtime > ui_current->last_mod) {
 							emperor_respawn(ui_current, st.st_mtime);
 						}
 					}
 					else {
-						emperor_add(g.gl_pathv[i], st.st_mtime, NULL, 0);
+						emperor_add(g.gl_pathv[i], st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
 					}
 				}
 
@@ -569,6 +754,12 @@ reconnect:
 			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);
 		}
@@ -587,26 +778,30 @@ reconnect:
 			if (amqp_fd > -1) {
 				if (!ui_current->loyal && (time(NULL)-ui_current->last_loyal) > 60) {
 					uwsgi_log("!!! no loyalty showed by instance %s !!!\n", ui_current->name);
+					// SAFE
 					emperor_del(ui_current);
 					break;
 				}
 			}
 			if (ui_current->status == 1) {
 				if (ui_current->config) free(ui_current->config);
+				// SAFE
 				emperor_del(ui_current);
 				break;
 			}
-			else if (!ui_current->use_config && strncmp(ui_current->name, "http://",7) && stat(ui_current->name, &st)) {
+			else if (!ui_current->use_config && strncmp(ui_current->name, "http://",7) && stat(ui_current->name, &st) && !ui_current->zerg) {
 				emperor_stop(ui_current);
 			}
 			else if (ui_current->pid == diedpid) {
 				if (ui_current->status == 0) {
 					// respawn an accidentally dead instance if its exit code is not UWSGI_EXILE_CODE
 					if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_EXILE_CODE) {
+						// SAFE
 						emperor_del(ui_current);
 					}
 					else {
-						emperor_add(ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len);
+						// UNSAFE
+						emperor_add(ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len, ui_current->uid, ui_current->gid);
 						emperor_del(ui_current);
 					}
 					break;
@@ -614,12 +809,83 @@ reconnect:
 				else if (ui_current->status == 1) {
 					// remove 'marked for dead' instance
 					if (ui_current->config) free(ui_current->config);
+					// SAFE
 					emperor_del(ui_current);
 					break;
 				}
 			}
 		}
 
+
 	}
 
 }
+
+#define stats_send_llu(x, y) fprintf(output, x, (long long unsigned int) y)
+#define stats_send(x, y) fprintf(output, x, y)
+
+void emperor_send_stats(int fd) {
+
+        struct sockaddr_un client_src;
+        socklen_t client_src_len = 0;
+        int client_fd = accept(fd, (struct sockaddr *) &client_src, &client_src_len);
+        if (client_fd < 0) {
+                uwsgi_error("accept()");
+                return;
+        }
+
+        FILE *output = fdopen(client_fd, "w");
+        if (!output) {
+                uwsgi_error("fdopen()");
+                close(client_fd);
+                return;
+        }
+
+        stats_send("{ \"version\": \"%s\",\n", UWSGI_VERSION);
+
+        fprintf(output,"\"uid\": %d,\n", (int)(getuid()));
+        fprintf(output,"\"gid\": %d,\n", (int)(getgid()));
+
+	char *cwd = uwsgi_get_cwd();
+        stats_send("\"cwd\": \"%s\",\n", cwd);
+        free(cwd);
+
+	stats_send("\"emperor\": \"%s\",\n", uwsgi.emperor_dir);
+
+        fprintf(output,"\"emperor_tyrant\": %d,\n", uwsgi.emperor_tyrant);
+
+
+        fprintf(output, "\"vassals\": [\n");
+
+	struct uwsgi_instance *c_ui = ui->ui_next;
+
+        while (c_ui) {
+                fprintf(output,"\t{");
+                stats_send("\"id\": \"%s\", ", c_ui->name);
+                fprintf(output,"\"pid\": %d, ", (int) c_ui->pid);
+
+		stats_send_llu( "\"born\": %llu, ", c_ui->born);
+		stats_send_llu( "\"last_mod\": %llu, ", c_ui->last_mod);
+
+                fprintf(output,"\"loyal\": %d, ", c_ui->loyal);
+                fprintf(output,"\"zerg\": %d, ", c_ui->zerg);
+
+                fprintf(output,"\"uid\": %d, ", (int)c_ui->uid);
+                fprintf(output,"\"gid\": %d, ", (int)c_ui->gid);
+
+		stats_send_llu( "\"respawns\": %llu ", c_ui->respawns);
+        	c_ui = c_ui->ui_next;
+
+		if (c_ui) {
+                	fprintf(output,"},\n");
+                }
+                else {
+                	fprintf(output,"}\n");
+                }
+        }
+
+
+	fprintf(output,"]}\n");
+        fclose(output);
+
+}

event.c

@@ -81,7 +81,7 @@ void *event_queue_alloc(int nevents) {
 int event_queue_interesting_fd(void *events, int id) {
 	port_event_t *pe = (port_event_t *) events;
 	if (pe[id].portev_source == PORT_SOURCE_FILE || pe[id].portev_source == PORT_SOURCE_TIMER) {
-                return (int) pe[id].portev_user;
+                return (long) pe[id].portev_user;
         }
 
 	return (int) pe[id].portev_object;
@@ -149,7 +149,7 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 
 
 	if (pe.portev_source == PORT_SOURCE_FILE || pe.portev_source == PORT_SOURCE_TIMER) {
-        	*interesting_fd = (int) pe.portev_user;
+        	*interesting_fd = (long) pe.portev_user;
 	}
 	else {
 		*interesting_fd = (int) pe.portev_object;
@@ -327,11 +327,13 @@ int event_queue_fd_write_to_read(int eq, int fd) {
 
 	struct kevent kev;
 
+#ifndef __FreeBSD__
         EV_SET(&kev, fd, EVFILT_WRITE, EV_DISABLE, 0, 0, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
                 uwsgi_error("kevent()");
                 return -1;
         }
+#endif
 
         EV_SET(&kev, fd, EVFILT_READ, EV_ADD, 0, 0, 0);
         if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {
@@ -476,7 +478,7 @@ int event_queue_add_file_monitor(int eq, char *filename, int *id) {
 	fo.fo_ctime = st.st_ctim;
 	
 	fmon_id++;
-	if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *) fmon_id)) {
+	if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *) (long) fmon_id)) {
 		uwsgi_error("port_associate()");
 		return -1;
 	}
@@ -506,7 +508,7 @@ struct uwsgi_fmon *event_queue_ack_file_monitor(int eq, int id) {
         			fo.fo_atime = st.st_atim;
         			fo.fo_mtime = st.st_mtim;
         			fo.fo_ctime = st.st_ctim;
-				if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *)id)) {
+				if (port_associate(eq, PORT_SOURCE_FILE, (uintptr_t) &fo, FILE_MODIFIED|FILE_ATTRIB, (void *)(long)id)) {
                 			uwsgi_error("port_associate()");
                 			return NULL;
         			}
@@ -591,7 +593,9 @@ int event_queue_add_file_monitor(int eq, char *filename, int *id) {
 
 	*id = inotify_add_watch(ifd, filename, IN_ATTRIB|IN_CREATE|IN_DELETE|IN_DELETE_SELF|IN_MODIFY|IN_MOVE_SELF|IN_MOVED_FROM|IN_MOVED_TO);
 		
+#ifdef UWSGI_DEBUG
 	uwsgi_log("added watch %d for filename %s\n", *id, filename);
+#endif
 
 	if (add_to_queue) {
 		return event_queue_add_fd_read(eq, ifd);
@@ -630,7 +634,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++) {
@@ -683,13 +689,21 @@ enum
 
 
 static int timerfd_create (clockid_t __clock_id, int __flags) {
+#ifdef __amd64__
+	return syscall(283, __clock_id, __flags);
+#elif defined(__i386__)
 	return syscall(322, __clock_id, __flags);
+#endif
 }
 
 static int timerfd_settime (int __ufd, int __flags,
                             __const struct itimerspec *__utmr,
                             struct itimerspec *__otmr) {
+#ifdef __amd64__
+	return syscall(286, __ufd, __flags, __utmr, __otmr);
+#elif defined(__i386__)
 	return syscall(325, __ufd, __flags, __utmr, __otmr);
+#endif
 }
 #endif
 
@@ -761,7 +775,7 @@ int event_queue_add_timer(int eq, int *id, int sec) {
 	timer_id++;
 
 	pnotif.portnfy_port = eq;
-	pnotif.portnfy_user = (void *) timer_id;
+	pnotif.portnfy_user = (void *) (long) timer_id;
 
 	sigev.sigev_notify = SIGEV_PORT;
 	sigev.sigev_value.sival_ptr = &pnotif;
@@ -816,8 +830,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()");

fdconf.pl

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

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

@@ -60,6 +60,11 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop)(void)) {
                         uwsgi_error("prctl()");
                 }
 #endif
+
+		if (!uwsgi.sockets) {
+			// wait for child end
+			//waitpid(-1, &i, 0);
+		}
 			loop();
 			// never here !!! (i hope)
 			exit(1);	
@@ -117,6 +122,12 @@ void gateway_respawn(int id) {
 	}
 
 	ug->pid = gw_pid;
-	uwsgi_log( "respawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	ug->respawns++;
+	if (ug->respawns == 1) {
+		uwsgi_log( "spawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	}
+	else {
+		uwsgi_log( "respawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	}
 	
 }

hello_world.py

@@ -0,0 +1,6 @@
+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')])
+    yield str(env['wsgi.input'].fileno())
+    yield "<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;
 
 }
@@ -87,7 +92,7 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 	char *section_asked = "uwsgi";
 	char *colon;
 
-	if (!uwsgi_startswith(file, "http://", 7)) {
+	if (uwsgi_check_scheme(file)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }
@@ -102,7 +107,9 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 		}
 	}
 
-	uwsgi_log("[uWSGI] getting INI configuration from %s\n", file);
+	if (file[0] != 0) {
+		uwsgi_log("[uWSGI] getting INI configuration from %s\n", file);
+	}
 
 	ini = uwsgi_open_and_read(file, &len, 1, magic_table);
 
@@ -143,6 +150,11 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 
 	}
 
+	if (colon) {
+		colon[0] = ':';
+	}
+
+
 }
 
 #endif

it.unbit.uwsgi.emperor.plist

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

it.unbit.uwsgi.plist

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

json.c

@@ -30,7 +30,7 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 	char *colon;
 	int i;
 
-	if (!uwsgi_startswith(file, "http://", 7)) {
+	if (uwsgi_check_scheme(file)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }
@@ -49,7 +49,11 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 
 	json_data = uwsgi_open_and_read(file, &len, 1, magic_table);
 
+#ifdef JANSSON_MAJOR_VERSION 
 	root = json_loads(json_data, 0, &error);
+#else
+	root = json_loads(json_data, &error);
+#endif
 
 	if (!root) {
 		uwsgi_log("error parsing JSON data: line %d %s\n", error.line, error.text);

lib/netlink.c

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

lib/rbtree.c

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

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

lock.c

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

logging.c

@@ -50,7 +50,7 @@ void log_request(struct wsgi_request *wsgi_req) {
 	if (wsgi_req->do_not_log) return ;
 
 	if (wsgi_req->app_id >= 0) {
-		wi = &uwsgi.apps[wsgi_req->app_id];
+		wi = &uwsgi_apps[wsgi_req->app_id];
 		if (wi->requests > 0) {
 			app_req = wi->requests;
 		}
@@ -173,6 +173,8 @@ void get_memusage() {
 
 #if defined(__FreeBSD__)
 	kv = kvm_open(NULL, "/dev/null", NULL, O_RDONLY, NULL);
+#elif defined(__NetBSD__) || defined(__OpenBSD__)
+	kv = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, NULL);
 #else
 	kv = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
 #endif

loop.c

@@ -66,23 +66,20 @@ void *simple_loop(void *arg1) {
 #endif
 
 	// initialize the main event queue to monitor sockets
-	uwsgi.main_queue = event_queue_init();
+	int main_queue = event_queue_init();
 
-	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
-	while(uwsgi_sock) {
-		event_queue_add_fd_read(uwsgi.main_queue, uwsgi_sock->fd);
-		uwsgi_sock = uwsgi_sock->next;
-	}
+	uwsgi_add_sockets_to_queue(main_queue);
 
 	if (uwsgi.signal_socket > -1) {
-		event_queue_add_fd_read(uwsgi.main_queue, uwsgi.signal_socket);
+		event_queue_add_fd_read(main_queue, uwsgi.signal_socket);
+		event_queue_add_fd_read(main_queue, uwsgi.my_signal_socket);
 	}
 
 	while (uwsgi.workers[uwsgi.mywid].manage_next_request) {
 
 		wsgi_req_setup(wsgi_req, core_id, NULL);
 
-		if (wsgi_req_accept(wsgi_req)) {
+		if (wsgi_req_accept(main_queue, wsgi_req)) {
 			continue;
 		}
 
@@ -94,9 +91,19 @@ void *simple_loop(void *arg1) {
 		uwsgi_close_request(wsgi_req);
 	}
 
-	pthread_exit(NULL);
-
-	//never here
+	// end of the loop
+	if (uwsgi.workers[uwsgi.mywid].destroy && uwsgi.workers[0].pid > 0) {
+#ifdef __APPLE__
+		kill(uwsgi.workers[0].pid, SIGTERM);
+#else
+		if (uwsgi.propagate_touch) {
+			kill(uwsgi.workers[0].pid, SIGHUP);
+		}
+		else {
+			gracefully_kill(0);
+		}
+#endif
+	}
 	return NULL;
 }
 
@@ -109,7 +116,7 @@ void *zeromq_loop(void *arg1) {
 
 	struct wsgi_request *wsgi_req = uwsgi.wsgi_requests[core_id];
 	uwsgi.zeromq_recv_flag = 0;
-	zmq_pollitem_t zmq_poll_items[2];
+	zmq_pollitem_t zmq_poll_items[3];
 	char uwsgi_signal;
 
 	if (uwsgi.threads > 1) {
@@ -153,6 +160,10 @@ void *zeromq_loop(void *arg1) {
 		zmq_poll_items[1].socket = NULL;
 		zmq_poll_items[1].fd = uwsgi.signal_socket;
 		zmq_poll_items[1].events = ZMQ_POLLIN;
+
+		zmq_poll_items[2].socket = NULL;
+		zmq_poll_items[2].fd = uwsgi.my_signal_socket;
+		zmq_poll_items[2].events = ZMQ_POLLIN;
 	}
 
 
@@ -165,7 +176,7 @@ void *zeromq_loop(void *arg1) {
 
 
 		if (uwsgi.signal_socket > -1) {
-			if (zmq_poll(zmq_poll_items, 2, -1) < 0) {
+			if (zmq_poll(zmq_poll_items, 3, -1) < 0) {
 				uwsgi_error("zmq_poll()");
 				continue;
 			}
@@ -178,7 +189,9 @@ void *zeromq_loop(void *arg1) {
                         		}
                 		}
                 		else {
+#ifdef UWSGI_DEBUG
                         		uwsgi_log_verbose("master sent signal %d to worker %d\n", uwsgi_signal, uwsgi.mywid);
+#endif
                         		if (uwsgi_signal_handler(uwsgi_signal)) {
                                 		uwsgi_log_verbose("error managing signal %d on worker %d\n", uwsgi_signal, uwsgi.mywid);
                         		}
@@ -186,6 +199,26 @@ void *zeromq_loop(void *arg1) {
 				continue;
 			}
 
+			if (zmq_poll_items[2].revents & ZMQ_POLLIN) {
+                                if (read(uwsgi.my_signal_socket, &uwsgi_signal, 1) <= 0) {
+                                        if (uwsgi.no_orphans) {
+                                                uwsgi_log_verbose("uWSGI worker %d screams: UAAAAAAH my master died, i will follow him...\n", uwsgi.mywid);
+                                                end_me(0);
+                                        }
+                                }
+                                else {
+#ifdef UWSGI_DEBUG
+                                        uwsgi_log_verbose("master sent signal %d to worker %d\n", uwsgi_signal, uwsgi.mywid);
+#endif
+                                        if (uwsgi_signal_handler(uwsgi_signal)) {
+                                                uwsgi_log_verbose("error managing signal %d on worker %d\n", uwsgi_signal, uwsgi.mywid);
+                                        }
+                                }
+                                continue;
+                        }
+
+			
+
 			if (zmq_poll_items[0].revents & ZMQ_POLLIN) {
 				wsgi_req->poll.fd = wsgi_req->socket->proto_accept(wsgi_req, uwsgi.zmq_socket->fd);
 			}
@@ -202,8 +235,7 @@ void *zeromq_loop(void *arg1) {
 	}
 
 
-	pthread_exit(NULL);
-        //never here
+        // end of the loop
         return NULL;
 }
 #endif

master_utils.c

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

mule.c

@@ -0,0 +1,115 @@
+/*
+
+uWSGI mules are very simple workers only managing signals or running custom code in background.
+
+By default they born in signal-only mode, but if you patch them (passing the script/code to run) they will became fully customized daemons.
+
+*/
+
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+void uwsgi_mule_handler(void);
+
+void uwsgi_mule(int id) {
+
+	int i;
+
+	pid_t pid = fork();
+	if (pid == 0) {
+		uwsgi.muleid = id;
+		// avoid race conditions
+		uwsgi.mules[id-1].id = id;
+		uwsgi.mules[id-1].pid = getpid();
+
+		uwsgi_fixup_fds(0, id);
+
+		uwsgi.my_signal_socket = uwsgi.mules[id-1].signal_pipe[1];
+		uwsgi.signal_socket = uwsgi.shared->mule_signal_pipe[1];
+
+		uwsgi_close_all_sockets();
+
+		for (i = 0; i < 0xFF; i++) {
+                	if (uwsgi.p[i]->master_fixup) {
+                		uwsgi.p[i]->master_fixup(1);
+                	}
+                }
+
+		for (i = 0; i < 0xFF; i++) {
+                        if (uwsgi.p[i]->post_fork) {
+                                uwsgi.p[i]->post_fork();
+                        }
+                }
+
+
+		if (uwsgi.mules[id-1].patch) {
+			uwsgi_log("loading patch %s\n", uwsgi.mules[id-1].patch);
+			for (i = 0; i < 0xFF; i++) {
+                        	if (uwsgi.p[i]->mule) {
+                                	if (uwsgi.p[i]->mule(uwsgi.mules[id-1].patch) == 1) {
+						break;
+					}
+				}
+                        }
+		}
+
+		uwsgi_mule_handler();
+	}
+	else if (pid > 0) {
+		uwsgi.mules[id-1].id = id;
+		uwsgi.mules[id-1].pid = pid;
+		uwsgi_log("spawned uWSGI mule %d (pid: %d)\n", id, (int) pid);
+	}
+}
+
+void uwsgi_mule_handler() {
+	
+	ssize_t len;
+	uint8_t uwsgi_signal;
+	int rlen;
+	int interesting_fd;
+	
+	// this must be configurable
+	char message[65536];
+
+	int mule_queue = event_queue_init();
+
+	event_queue_add_fd_read(mule_queue, uwsgi.signal_socket);
+	event_queue_add_fd_read(mule_queue, uwsgi.my_signal_socket);
+	event_queue_add_fd_read(mule_queue, uwsgi.mules[uwsgi.muleid-1].queue_pipe[1]);
+
+	for(;;) {
+		rlen = event_queue_wait(mule_queue, -1, &interesting_fd);
+		if (rlen <= 0) {
+			continue;
+		}
+
+		if (interesting_fd == uwsgi.signal_socket || interesting_fd == uwsgi.my_signal_socket) {
+			len = read(interesting_fd, &uwsgi_signal, 1);
+			if (len <= 0) {
+                		uwsgi_log_verbose("uWSGI mule %d braying: my master died, i will follow him...\n", uwsgi.muleid);
+                        	end_me(0);
+                	}
+#ifdef UWSGI_DEBUG
+			uwsgi_log_verbose("master sent signal %d to mule %d\n", uwsgi_signal, uwsgi.muleid);
+#endif
+			if (uwsgi_signal_handler(uwsgi_signal)) {
+                		uwsgi_log_verbose("error managing signal %d on mule %d\n", uwsgi_signal, uwsgi.mywid);
+                	}
+		}
+		else if (interesting_fd == uwsgi.mules[uwsgi.muleid-1].queue_pipe[1]) {
+			len = read(uwsgi.mules[uwsgi.muleid-1].queue_pipe[1], message, 65536);
+			if (len < 0) {
+				uwsgi_error("read()");
+			}	
+			else if (len == 0) {
+				exit(1);
+			}
+			else {
+				uwsgi_log("*** mule %d received a %d bytes message\n", uwsgi.muleid, len);
+			}
+		}
+	}
+
+}

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/admin/admin_plugin.c

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

plugins/admin/uwsgiplugin.py

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

plugins/cache/cache.c

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

plugins/cplusplus/base.cc

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

plugins/cplusplus/plugin.c

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

plugins/cplusplus/uwsgiplugin.py

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

plugins/echo/echo_plugin.c

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

plugins/example/example_plugin.c

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

plugins/example/uwsgiplugin.py

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

plugins/fastrouter/fastrouter.c

@@ -18,6 +18,8 @@
 #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 LONG_ARGS_FASTROUTER_USE_CODE_STRING		150008
 
 #define FASTROUTER_STATUS_FREE 0
 #define FASTROUTER_STATUS_CONNECTING 1
@@ -28,32 +30,81 @@
 #define add_timeout(x) uwsgi_add_rb_timer(ufr.timeouts, time(NULL)+ufr.socket_timeout, x)
 #define del_timeout(x) rb_erase(&x->timeout->rbt, ufr.timeouts); free(x->timeout);
 
+struct uwsgi_fastrouter_socket {
+	char *name;
+	int fd;
+	struct uwsgi_fastrouter_socket *next;
+};
+
 struct uwsgi_fastrouter {
-	char *socket_name;
-	int use_cache;
-	int nevents;
 
-	char *pattern;
-	int pattern_len;
+        struct uwsgi_fastrouter_socket *sockets;
 
-	char *base;
-	int base_len;
+        int use_cache;
+        int nevents;
 
-	char *subscription_server;
-	struct uwsgi_dict *subscription_dict;
+	int queue;
 
-	int socket_timeout;
+        int subscription_slot;
 
-	struct rb_root *timeouts;
+        char *pattern;
+        int pattern_len;
+
+        char *base;
+        int base_len;
+
+        char *subscription_server;
+        struct uwsgi_dict *subscription_dict;
+
+        int socket_timeout;
+
+	uint8_t code_string_modifier1;
+	char *code_string_code;
+	char *code_string_function;
+
+        struct rb_root *timeouts;
+
+	int cheap;
+	int i_am_cheap;
 } 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-use-code-string", required_argument, 0, LONG_ARGS_FASTROUTER_USE_CODE_STRING},
 	{"fastrouter-events", required_argument, 0, LONG_ARGS_FASTROUTER_EVENTS},
+	{"fastrouter-cheap", no_argument, &ufr.cheap, 1},
 	{"fastrouter-subscription-server", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER},
+	{"fastrouter-subscription-slot", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT},
 	{"fastrouter-timeout", required_argument, 0, LONG_ARGS_FASTROUTER_TIMEOUT},
 	{0, 0, 0, 0},	
 };
@@ -72,6 +123,10 @@ void fastrouter_manage_subscription(char *key, uint16_t keylen, char *val, uint1
 		usr->address = val;
 		usr->address_len = vallen;
 	}
+
+	else if (!uwsgi_strncmp("modifier1", 9, key, keylen)) {
+		usr->modifier1 = uwsgi_str_num(val, vallen);
+	}
 }
 
 struct fastrouter_session {
@@ -87,6 +142,8 @@ struct fastrouter_session {
 	char *hostname;
 	uint16_t hostname_len;
 
+	int has_key;
+
 	char *instance_address;
 	uint64_t instance_address_len;
 
@@ -95,6 +152,8 @@ struct fastrouter_session {
 
 	struct uwsgi_rb_timer *timeout;
 	int instance_failed;
+
+	uint8_t modifier1;
 };
 
 static void close_session(struct fastrouter_session **fr_table, struct fastrouter_session *fr_session) {
@@ -103,8 +162,22 @@ static void close_session(struct fastrouter_session **fr_table, struct fastroute
 	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;
+			uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
+			if (fr_session->un->len > 0) {
+				if (ufr.subscription_dict->count > 0) {
+                                	ufr.subscription_dict->count--;
+                                }
+                                if (ufr.subscription_dict->count == 0 && ufr.cheap && !ufr.i_am_cheap) {
+                                	uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
+                                        struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+                                        while(ufr_sock) {
+                                        	event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());
+                                                ufr_sock = ufr_sock->next;
+                                        }
+					ufr.i_am_cheap = 1;
+                                }
+
+			}
 		}
 		close(fr_session->instance_fd);
 		fr_table[fr_session->instance_fd] = NULL;
@@ -148,7 +221,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;
@@ -162,8 +242,6 @@ struct fastrouter_session *alloc_fr_session() {
 
 void fastrouter_loop() {
 
-	int fr_queue;
-	int fr_server = -1;
 	int nevents;
 	int interesting_fd;
 	int new_connection;
@@ -210,37 +288,51 @@ void fastrouter_loop() {
 		fr_table[i] = NULL;
 	}
 
-	if (ufr.socket_name[0] == '=') {
-		int shared_socket = atoi(ufr.socket_name+1);
-		if (shared_socket >= 0 && shared_socket < uwsgi.shared_sockets_cnt) {
-			if (uwsgi.shared_sockets[shared_socket].name) {
-				fr_server = uwsgi.shared_sockets[shared_socket].fd;
-			}	
-			else {
-				uwsgi_log("unable to use shared socket %d\n", shared_socket);
+	ufr.queue = event_queue_init();
+
+	struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+
+	while(ufr_sock) {
+		if (ufr_sock->name[0] == '=') {
+			int shared_socket = atoi(ufr_sock->name+1);
+			if (shared_socket >= 0) {
+				ufr_sock->fd = uwsgi_get_shared_socket_fd_by_num(shared_socket);
+				if (ufr_sock->fd == -1) {
+					uwsgi_log("unable to use shared socket %d\n", shared_socket);
+				}
 			}
 		}
-	}
-	else {
-		tcp_port = strchr(ufr.socket_name, ':');
-		if (tcp_port) {
-			fr_server = bind_to_tcp(ufr.socket_name, uwsgi.listen_queue, tcp_port);
+		else {
+			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);
+			}
+		}
+
+		uwsgi_log("uwsgi fastrouter/proxy bound on %s\n", ufr_sock->name);
+
+		if (!ufr.cheap) {
+			event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
 		}
 		else {
-			fr_server = bind_to_unix(ufr.socket_name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+			uwsgi_log("[uwsgi-fastrouter] cheap mode requested. Waiting for subscriptions...\n");
+			ufr.i_am_cheap = 1;
 		}
+		ufr_sock = ufr_sock->next;
 	}
 
-	fr_queue = event_queue_init();
 
 	events = event_queue_alloc(ufr.nevents);
 
-	event_queue_add_fd_read(fr_queue, fr_server);
 
 	if (ufr.subscription_server) {
 		ufr_subserver = bind_to_udp(ufr.subscription_server, 0, 0);
-		event_queue_add_fd_read(fr_queue, ufr_subserver);
-		ufr.subscription_dict = uwsgi_dict_create(30, 0);
+		event_queue_add_fd_read(ufr.queue, ufr_subserver);
+		if (!ufr.subscription_slot) ufr.subscription_slot = 30;
+		ufr.subscription_dict = uwsgi_dict_create(ufr.subscription_slot, 0);
 	}
 
 	if (ufr.pattern) {
@@ -264,7 +356,7 @@ void fastrouter_loop() {
 			}
 		}
 
-		nevents = event_queue_wait_multi(fr_queue, delta, events, ufr.nevents);
+		nevents = event_queue_wait_multi(ufr.queue, delta, events, ufr.nevents);
 
 		if (nevents == 0) {
 			expire_timeouts(fr_table);
@@ -276,35 +368,57 @@ void fastrouter_loop() {
 			interesting_fd = event_queue_interesting_fd(events, i);
 
 
-			if (interesting_fd == fr_server) {
-				new_connection = accept(fr_server, (struct sockaddr *) &fr_addr, &fr_addr_len);
-				if (new_connection < 0) {
-					continue;
-				}
+			int taken = 0;
+			struct uwsgi_fastrouter_socket *uwsgi_sock = ufr.sockets;
+			while(uwsgi_sock) {
+				if (interesting_fd == uwsgi_sock->fd) {
+					new_connection = accept(interesting_fd, (struct sockaddr *) &fr_addr, &fr_addr_len);
+					if (new_connection < 0) {
+						continue;
+					}
 
-				fr_table[new_connection] = alloc_fr_session();
-				fr_table[new_connection]->fd = new_connection;
-				fr_table[new_connection]->instance_fd = -1; 
-				fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
-				fr_table[new_connection]->h_pos = 0;
-				fr_table[new_connection]->pos = 0;
-				fr_table[new_connection]->instance_failed = 0;
-				fr_table[new_connection]->instance_address_len = 0;
+					fr_table[new_connection] = alloc_fr_session();
+					fr_table[new_connection]->fd = new_connection;
+					fr_table[new_connection]->instance_fd = -1; 
+					fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
+					fr_table[new_connection]->h_pos = 0;
+					fr_table[new_connection]->pos = 0;
+					fr_table[new_connection]->un = NULL;
+					fr_table[new_connection]->instance_failed = 0;
+					fr_table[new_connection]->instance_address_len = 0;
 		
-				fr_table[new_connection]->timeout = add_timeout(fr_table[new_connection]);
+					fr_table[new_connection]->timeout = add_timeout(fr_table[new_connection]);
 
-				event_queue_add_fd_read(fr_queue, new_connection);
+					event_queue_add_fd_read(ufr.queue, new_connection);
+					taken = 1;
+					break;
+				}
 				
+				uwsgi_sock = uwsgi_sock->next;
 			}	
-			else if (interesting_fd == ufr_subserver) {
+
+			if (taken) {
+				continue;
+			}
+
+			if (interesting_fd == ufr_subserver) {
 				len = recv(ufr_subserver, bbuf, 4096, 0);
 #ifdef UWSGI_EVENT_USE_PORT
-				event_queue_add_fd_read(fr_queue, ufr_subserver);
+				event_queue_add_fd_read(ufr.queue, ufr_subserver);
 #endif
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
-					uwsgi_add_subscriber(ufr.subscription_dict, usr.key, usr.keylen, usr.address, usr.address_len);
+					uwsgi_add_subscriber(ufr.subscription_dict, &usr);
+					if (ufr.i_am_cheap) {
+						struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
+                                                while(ufr_sock) {
+                                                	event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
+                                                        ufr_sock = ufr_sock->next;
+                                                }
+						ufr.i_am_cheap = 0;
+						uwsgi_log("[uwsgi-fastrouter] leaving cheap mode...\n");	
+					}
 				}
 			}
 			else {
@@ -358,9 +472,16 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
-							//uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
+#ifdef UWSGI_DEBUG
+							uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
+#endif
 							if (ufr.use_cache) {
 								fr_session->instance_address = uwsgi_cache_get(fr_session->hostname, fr_session->hostname_len, &fr_session->instance_address_len);
+								char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
+                                                                if (cs_mod) {
+                                                                	fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
+                                                                        fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
+                                                                }
 							}
 							else if (ufr.pattern) {
 								magic_table['s'] = uwsgi_concat2n(fr_session->hostname, fr_session->hostname_len, "", 0);	
@@ -374,6 +495,7 @@ void fastrouter_loop() {
 								if (fr_session->un && fr_session->un->len) {
 									fr_session->instance_address = fr_session->un->name;
 									fr_session->instance_address_len = fr_session->un->len;
+									fr_session->modifier1 = fr_session->un->modifier1;
 								}
 							}
 							else if (ufr.base) {
@@ -381,6 +503,19 @@ void fastrouter_loop() {
 								fr_session->instance_address_len = tmp_socket_name_len;
 								fr_session->instance_address = tmp_socket_name;
 							}
+							else if (ufr.code_string_code && ufr.code_string_function) {
+								if (uwsgi.p[ufr.code_string_modifier1]->code_string) {
+									fr_session->instance_address = uwsgi.p[ufr.code_string_modifier1]->code_string("uwsgi_fastrouter", ufr.code_string_code, ufr.code_string_function, fr_session->hostname, fr_session->hostname_len);
+									if (fr_session->instance_address) {
+										fr_session->instance_address_len = strlen(fr_session->instance_address);
+										char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
+										if (cs_mod) {
+											fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
+											fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
+										}
+									}
+								}
+							}
 
 							// no address found
 							if (!fr_session->instance_address_len) {
@@ -397,8 +532,22 @@ void fastrouter_loop() {
 
 							if (fr_session->instance_fd < 0) {
 								if (ufr.subscription_server) {
-	                                                        	uwsgi_log("marking %.*s as failed\n", (int) fr_session->instance_address_len,fr_session->instance_address);
-	                                                        	fr_session->un->len = 0;
+	                                                        	uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
+									if (fr_session->un->len > 0) { 
+                                						fr_session->un->len = 0; 
+										if (ufr.subscription_dict->count > 0) {
+                                							ufr.subscription_dict->count--;
+										}
+										if (ufr.subscription_dict->count == 0 && ufr.cheap && !ufr.i_am_cheap) {
+											uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
+											struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;	
+											while(ufr_sock) {
+												event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());	
+												ufr_sock = ufr_sock->next;
+											}
+											ufr.i_am_cheap = 1;
+										}
+                        						}
 	                                                        }
 								close_session(fr_table, fr_session);
                                                         	break;
@@ -407,7 +556,7 @@ void fastrouter_loop() {
 
 							fr_session->status = FASTROUTER_STATUS_CONNECTING;
 							fr_table[fr_session->instance_fd] = fr_session;
-							event_queue_add_fd_write(fr_queue, fr_session->instance_fd);
+							event_queue_add_fd_write(ufr.queue, fr_session->instance_fd);
                                                 }
                                                 break;
 
@@ -431,13 +580,19 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
+							fr_session->uh.modifier1 = fr_session->modifier1;
+
 							iov[0].iov_base = &fr_session->uh;
 							iov[0].iov_len = 4;
 							iov[1].iov_base = fr_session->buffer;
 							iov[1].iov_len = fr_session->uh.pktsize;
 
+							// increment node requests counter
+							if (fr_session->un)
+								fr_session->un->requests++;
+
 							// fd passing: PERFORMANCE EXTREME BOOST !!!
-							if (fr_session->pass_fd) {
+							if (fr_session->pass_fd && !uwsgi.no_fd_passing) {
 								msg.msg_name    = NULL;
                 						msg.msg_namelen = 0;
                 						msg.msg_iov     = iov;
@@ -467,7 +622,7 @@ void fastrouter_loop() {
                                                         	break;
 							}
 
-							event_queue_fd_write_to_read(fr_queue, fr_session->instance_fd);
+							event_queue_fd_write_to_read(ufr.queue, fr_session->instance_fd);
 							fr_session->status = FASTROUTER_STATUS_RESPONSE;
 						}
 
@@ -491,6 +646,10 @@ void fastrouter_loop() {
 								close_session(fr_table, fr_session);
                                                         	break;
 							}
+
+							// update transfer statistics
+							if (fr_session->un)
+								fr_session->un->transferred += len;
 						}
 						// body from client
 						else if (interesting_fd == fr_session->fd) {
@@ -532,7 +691,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");
@@ -541,9 +700,17 @@ int fastrouter_init() {
 
 		if (!ufr.nevents) ufr.nevents = 64;
 
-		if (register_gateway("fastrouter", fastrouter_loop) == NULL) {
-			uwsgi_log("unable to register the fastrouter gateway\n");
-			exit(1);
+		if (ufr.code_string_code && ufr.code_string_function) {
+			if (register_fat_gateway("fastrouter", fastrouter_loop) == NULL) {
+				uwsgi_log("unable to register the fastrouter gateway\n");
+				exit(1);
+			}
+		}
+		else {
+			if (register_gateway("fastrouter", fastrouter_loop) == NULL) {
+				uwsgi_log("unable to register the fastrouter gateway\n");
+				exit(1);
+			}
 		}
 	}
 
@@ -552,9 +719,13 @@ int fastrouter_init() {
 	
 int fastrouter_opt(int i, char *optarg) {
 
+	char *cs;
+	char *cs_code;
+	char *cs_func;
+
 	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;
@@ -572,9 +743,30 @@ int fastrouter_opt(int i, char *optarg) {
 			// optimization
 			ufr.base_len = strlen(ufr.base);
 			return 1;
+		case LONG_ARGS_FASTROUTER_USE_CODE_STRING:
+			cs = uwsgi_str(optarg);
+			cs_code = strchr(cs, ':');
+			if (!cs_code) {
+				uwsgi_log("invalid code_string option\n");
+				exit(1);	
+			}
+			cs_code[0] = 0;
+			cs_func = strchr(cs_code+1, ':');
+			if (!cs_func) {
+				uwsgi_log("invalid code_string option\n");
+				exit(1);	
+			}
+			cs_func[0] = 0;
+			ufr.code_string_modifier1 = atoi(cs);
+			ufr.code_string_code = cs_code+1;
+			ufr.code_string_function = cs_func+1;
+			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;
 }

plugins/gevent/gevent.c

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

plugins/gevent/uwsgiplugin.py

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

plugins/http/http.c

@@ -403,6 +403,14 @@ int http_parse(struct http_session *h_session) {
 		ptr++;
 	}
 
+	int i;
+	for(i=0;i<uhttp.http_vars_cnt;i++) {
+		char *equal = strchr(uhttp.http_vars[i],'=');
+		if (equal) {
+			h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, uhttp.http_vars[i], equal-uhttp.http_vars[i], equal+1, strlen(equal+1), &c);
+		}
+	}
+
 #ifdef UWSGI_DEBUG
 	uwsgi_log("vec size: %d pkt size: %d load %d\n", c, h_session->uh.pktsize, uhttp.load);
 #endif
@@ -542,7 +550,7 @@ void http_loop() {
 				if (len > 0) {
 					memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
 					uwsgi_hooked_parse(bbuf+4, len-4, http_manage_subscription, &usr);
-					uwsgi_add_subscriber(uhttp.subscription_dict, usr.key, usr.keylen, usr.address, usr.address_len);
+					uwsgi_add_subscriber(uhttp.subscription_dict, &usr);
 				}
 			}
 			else {
@@ -639,6 +647,7 @@ void http_loop() {
 								}
 
 
+
 								uhttp_session->pass_fd = is_unix(uhttp_session->instance_address, uhttp_session->instance_address_len);
 
 								uhttp_session->instance_fd = uwsgi_connectn(uhttp_session->instance_address, uhttp_session->instance_address_len, 0, 1);
@@ -710,7 +719,7 @@ void http_loop() {
 
 #ifndef __sun__
 							// fd passing: PERFORMANCE EXTREME BOOST !!!
-							if (uhttp_session->pass_fd && !uhttp_session->remains) {
+							if (uhttp_session->pass_fd && !uhttp_session->remains && !uwsgi.no_fd_passing) {
 								msg.msg_name    = NULL;
                 						msg.msg_namelen = 0;
                 						msg.msg_iov     = uhttp_session->iov;
@@ -869,9 +878,7 @@ int http_init() {
 		if (!uhttp.nevents) uhttp.nevents = 64;
 
 		if (!uhttp.base && !uhttp.use_cache && !uhttp.to && !uwsgi.sockets && !uhttp.subscription_server && !uhttp.use_cluster) {
-			char *rand_name = uwsgi_malloc(64);
-			snprintf(rand_name, 64, "%d_%d.sock", (int) time(NULL), (int) getpid());
-			uwsgi.sockets = uwsgi_new_socket(rand_name);
+			uwsgi_new_socket(uwsgi_concat2("127.0.0.1:0", ""));
 		}
 
 		uhttp.server = bind_to_tcp(uhttp.socket_name, uwsgi.listen_queue, strchr(uhttp.socket_name,':'));

plugins/jvm/uwsgiplugin.py

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

plugins/lua/lua_plugin.c

@@ -374,7 +374,7 @@ void uwsgi_lua_app() {
 			luaL_openlibs(ulua.L[i]);
 			luaL_register(ulua.L[i], "uwsgi", uwsgi_api);
 			if (luaL_loadfile(ulua.L[i], ulua.filename)) {
-				uwsgi_log("unable to load file %s\n", ulua.filename);
+				uwsgi_log("unable to load file %s: %s\n", ulua.filename, lua_tostring(ulua.L[i], -1));
 				exit(1);
 			}
 			// use a pcall
@@ -403,8 +403,7 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 		if ((i = lua_pcall(L, 0, 1, 0)) == 0) {
 			if (lua_type(L, -1) == LUA_TSTRING) {
 				http = lua_tolstring(L, -1, &slen);
-				if ( (rlen = write(wsgi_req->poll.fd, http, slen)) != (ssize_t) slen) {
-					perror("write()");
+				if ( (rlen = wsgi_req->socket->proto_write(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
 					return UWSGI_OK;
 				}
 				wsgi_req->response_size += rlen;
@@ -420,12 +419,12 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	/* Standard WSAPI request */
 	if (!wsgi_req->uh.pktsize) {
 		uwsgi_log( "Invalid WSAPI request. skip.\n");
-		goto clear;
+		goto clear2;
 	}
 
 	if (uwsgi_parse_vars(wsgi_req)) {
 		uwsgi_log("Invalid WSAPI request. skip.\n");
-		goto clear;
+		goto clear2;
 	}
 
 	// put function in the stack
@@ -453,12 +452,16 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	lua_setfield(L, -2, "read");
 	lua_setfield(L, -2, "input");
 
+#ifdef UWSGI_DEBUG
+	uwsgi_log("stack pos %d\n", lua_gettop(L));
+#endif
 
 	// call function
 	i = lua_pcall(L, 1, 3, 0);
 	if (i != 0) {
 		uwsgi_log("%s\n", lua_tostring(L, -1));
 		lua_pop(L, 1);
+                lua_pushvalue(L, -1);
 		goto clear;
 	}
 
@@ -468,26 +471,30 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	// send status
 	if (lua_type(L, -3) == LUA_TSTRING || lua_type(L, -3) == LUA_TNUMBER) {
 		http = lua_tolstring(L, -3, &slen);
-		if (write(wsgi_req->poll.fd, wsgi_req->protocol, wsgi_req->protocol_len) != wsgi_req->protocol_len) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, wsgi_req->protocol, wsgi_req->protocol_len)) != wsgi_req->protocol_len) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, " ", 1) != 1) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, " ", 1)) != 1) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		// a performance hack
 		ptrbuf = (char *) http;
 		ptrbuf[3] = 0;
 		wsgi_req->status = atoi(ptrbuf);
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 	}
 	else {
 		raw = 1;
@@ -499,31 +506,41 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	lua_pushnil(L);
 	while(lua_next(L, -3) != 0) {
 		http = lua_tolstring(L, -2, &slen);
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, ": ", 2) != 2) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, ": ", 2)) != 2) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		http = lua_tolstring(L, -1, &slen);
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		lua_pop(L, 1);
+		wsgi_req->header_cnt++;
 	}
 
 	if (!raw) {
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 	}
 
 	// send body with coroutine
@@ -532,8 +549,9 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	while ( (i = lua_pcall(L, 0, 1, 0)) == 0) {
 		if (lua_type(L, -1) == LUA_TSTRING) {
 			http = lua_tolstring(L, -1, &slen);
-			if ( (rlen = write(wsgi_req->poll.fd, http, slen)) != (ssize_t) slen) {
-				perror("write()");
+			if ( (rlen = wsgi_req->socket->proto_write(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+				lua_pop(L, 1);
+                		lua_pushvalue(L, -1);
 				goto clear;
 			}
 			wsgi_req->response_size += rlen;
@@ -550,6 +568,7 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 clear:
 
 	lua_pop(L, 4);
+clear2:
 
 	// set frequency
 	lua_gc(L, LUA_GCCOLLECT, 0);
@@ -590,6 +609,55 @@ int uwsgi_lua_magic(char *mountpoint, char *lazy) {
 	return 0;
 }
 
+char *uwsgi_lua_code_string(char *id, char *code, char *func, char *key, uint16_t keylen) {
+
+	static struct lua_State *L = NULL;
+
+	if (!L) {
+		L = luaL_newstate();
+                luaL_openlibs(L);
+                if (luaL_loadfile(L, code) || lua_pcall(L, 0, 0, 0)) {
+                	uwsgi_log("unable to load file %s: %s\n", code, lua_tostring(L, -1));
+			lua_close(L);
+			L = NULL;
+			return NULL;
+                }
+		lua_getglobal(L, func);
+		if (!lua_isfunction(L,-1)) {
+			uwsgi_log("unable to find %s function in lua file %s\n", func, code);
+			lua_close(L);
+			L = NULL;
+			return NULL;
+		}
+		lua_pushnil(L);
+	}
+
+	
+	lua_pop(L, 1);
+
+	lua_pushvalue(L, -1);
+	lua_pushlstring(L, key, keylen);
+
+#ifdef UWSGI_DEBUG
+	uwsgi_log("stack pos %d %.*s\n", lua_gettop(L), keylen, key);
+#endif
+
+        if (lua_pcall(L, 1, 1, 0) != 0) {
+		uwsgi_log("CAZZO\n");
+                uwsgi_log("error running function `f': %s",
+                 lua_tostring(L, -1));
+                return NULL;
+
+        }
+
+	if (lua_isstring(L, -1)) {
+                const char *ret = lua_tolstring(L, -1, NULL);
+		return (char *)ret;
+        }
+
+        return NULL;
+}
+
 int uwsgi_lua_signal_handler(uint8_t sig, void *handler) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -664,6 +732,8 @@ struct uwsgi_plugin lua_plugin = {
 	.init_apps = uwsgi_lua_app,
 	.magic = uwsgi_lua_magic,
 	.signal_handler = uwsgi_lua_signal_handler,
+
+	.code_string = uwsgi_lua_code_string,
 	.rpc = uwsgi_lua_rpc,
 
 };

plugins/nagios/nagios.c

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

plugins/ping/ping_plugin.c

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

plugins/proxy/proxy.c

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

plugins/proxy/uwsgiplugin.py

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

plugins/psgi/psgi_plugin.c

@@ -3,7 +3,11 @@
 extern char **environ;
 extern struct uwsgi_server uwsgi;
 
+#ifdef __APPLE__
+extern struct uwsgi_perl uperl;
+#else
 struct uwsgi_perl uperl;
+#endif
 
 struct option uwsgi_perl_options[] = {
 
@@ -257,6 +261,10 @@ SV *build_psgi_env(struct wsgi_request *wsgi_req) {
 	
 	if (!hv_store(env, "psgix.input.buffered", 20, newSViv(wsgi_req->body_as_file), 0)) goto clear;
 
+	if (uwsgi.master_process) {
+		if (!hv_store(env, "psgix.harakiri", 14, newSViv(1), 0)) goto clear;
+	}
+
 	SV *pe = uwsgi_perl_obj_new("uwsgi::error", 12);
         if (!hv_store(env, "psgi.errors", 11, pe, 0)) goto clear;
 
@@ -272,7 +280,7 @@ int uwsgi_perl_init(){
 
 	struct http_status_codes *http_sc;
 
-	int argc = 3;
+	int argc;
 	uperl.embedding[0] = "";
 	uperl.embedding[1] = "-e";
 	uperl.embedding[2] = "0";
@@ -281,11 +289,18 @@ int uwsgi_perl_init(){
 		uwsgi_error("setenv()");
 	}
 
+	if (setenv("PLACK_SERVER", "uwsgi", 0)) {
+		uwsgi_error("setenv()");
+	}
+
 #ifdef PERL_VERSION_STRING
 	uwsgi_log("initializing Perl %s environment\n", PERL_VERSION_STRING);
 #else
 	uwsgi_log("initializing Perl environment\n");
 #endif
+
+	argc = 3;
+
 	PERL_SYS_INIT3(&argc, (char ***) &uperl.embedding, &environ);
 	uperl.main = perl_alloc();
 	if (!uperl.main) {
@@ -364,6 +379,7 @@ void uwsgi_perl_enable_threads() {
 
 int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 
+	SV **harakiri;
 	SV *psgi_func = uperl.psgi_main;
 	// ugly hack
 	register PerlInterpreter *my_perl = uperl.main;
@@ -426,6 +442,12 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	}
 
 clear2:
+	// check for psgix.harakiri
+        harakiri = hv_fetch((HV*)SvRV( (SV*)wsgi_req->async_environ), "psgix.harakiri.commit", 21, 0);
+        if (harakiri) {
+                if (SvTRUE(*harakiri)) wsgi_req->async_plagued = 1;
+        }
+
 	SvREFCNT_dec(wsgi_req->async_environ);
 	SvREFCNT_dec(wsgi_req->async_result);
 clear:
@@ -441,6 +463,12 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
 
 	if (uwsgi.shared->options[UWSGI_OPTION_LOGGING])
 		log_request(wsgi_req);
+
+	if (wsgi_req->async_plagued) {
+		uwsgi_log("*** psgix.harakiri.commit requested ***\n");
+		goodbye_cruel_world();
+	}
+
 }
 
 void uwsgi_perl_init_thread(int core_id) {

plugins/psgi/psgi_response.c

@@ -2,52 +2,7 @@
 
 extern struct uwsgi_server uwsgi;
 
-/* statistically ordered */
-struct http_status_codes hsc[] = {
-        {"200", "OK"},
-        {"302", "Found"},
-        {"404", "Not Found"},
-        {"500", "Internal Server Error"},
-        {"301", "Moved Permanently"},
-        {"304", "Not Modified"},
-        {"303", "See Other"},
-        {"403", "Forbidden"},
-        {"307", "Temporary Redirect"},
-        {"401", "Unauthorized"},
-        {"400", "Bad Request"},
-        {"405", "Method Not Allowed"},
-        {"408", "Request Timeout"},
-
-        {"100", "Continue"},
-        {"101", "Switching Protocols"},
-        {"201", "Created"},
-        {"202", "Accepted"},
-        {"203", "Non-Authoritative Information"},
-        {"204", "No Content"},
-        {"205", "Reset Content"},
-        {"206", "Partial Content"},
-        {"300", "Multiple Choices"},
-        {"305", "Use Proxy"},
-        {"402", "Payment Required"},
-        {"406", "Not Acceptable"},
-        {"407", "Proxy Authentication Required"},
-        {"409", "Conflict"},
-        {"410", "Gone"},
-        {"411", "Length Required"},
-        {"412", "Precondition Failed"},
-        {"413", "Request Entity Too Large"},
-        {"414", "Request-URI Too Long"},
-        {"415", "Unsupported Media Type"},
-        {"416", "Requested Range Not Satisfiable"},
-        {"417", "Expectation Failed"},
-        {"501", "Not Implemented"},
-        {"502", "Bad Gateway"},
-        {"503", "Service Unavailable"},
-        {"504", "Gateway Timeout"},
-        {"505", "HTTP Version Not Supported"},
-        { "", NULL },
-};
-
+extern struct http_status_codes hsc[];
 
 int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *response) {
 
@@ -57,6 +12,7 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
 	struct http_status_codes *http_sc;
 	int i,vi, base;
 	char *chitem;
+	SV **harakiri;
 
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
@@ -84,6 +40,12 @@ int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *r
                         	SvREFCNT_dec(closed);
                 	}
 
+			// check for psgix.harakiri
+        		harakiri = hv_fetch((HV*)SvRV( (SV*)wsgi_req->async_environ), "psgix.harakiri.commit", 21, 0);
+        		if (harakiri) {
+                		if (SvTRUE(*harakiri)) wsgi_req->async_plagued = 1;
+        		}
+
 			SvREFCNT_dec(wsgi_req->async_environ);
         		SvREFCNT_dec(wsgi_req->async_result);
 

plugins/psgi/uwsgi_plmodule.c

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

plugins/psgi/uwsgiplugin.py

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

plugins/python/gil.c

@@ -3,16 +3,25 @@
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
+#ifdef UWSGI_PYPY
+void gil_real_get() {}
+void gil_real_release() {}
+#else
+
 void gil_real_get() {
+	//uwsgi_log("LOCK %d\n", uwsgi.mywid);
 #ifndef PYTHREE
 	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();	
@@ -22,5 +31,7 @@ void gil_real_release() {
 #endif
 }
 
+#endif
+
 void gil_fake_get() {}
 void gil_fake_release() {}

plugins/python/profiler.c

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

plugins/python/pump_subhandler.c

@@ -0,0 +1,392 @@
+#include "uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
+
+
+extern struct http_status_codes hsc[];
+
+
+void *uwsgi_request_subhandler_pump(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
+
+	PyObject *zero;
+
+	int i;
+        PyObject *pydictkey, *pydictvalue;
+
+	char *port = memchr(wsgi_req->host, ':', wsgi_req->host_len);
+	if (port) {
+
+		zero = PyString_FromStringAndSize(wsgi_req->host, (port-wsgi_req->host));
+		PyDict_SetItemString(wsgi_req->async_environ, "server_name", zero);
+		Py_DECREF(zero);
+
+		zero = PyString_FromStringAndSize(port, wsgi_req->host_len-((port+1)-wsgi_req->host));
+		PyDict_SetItemString(wsgi_req->async_environ, "server_port", zero);
+		Py_DECREF(zero);
+	}
+	else {
+
+		zero = PyString_FromStringAndSize(wsgi_req->host, wsgi_req->host_len);
+		PyDict_SetItemString(wsgi_req->async_environ, "server_name", zero);
+		Py_DECREF(zero);
+
+		zero = PyString_FromStringAndSize("80", 2);
+		PyDict_SetItemString(wsgi_req->async_environ, "server_port", zero);
+		Py_DECREF(zero);
+	}
+
+	zero = PyString_FromStringAndSize(wsgi_req->remote_addr, wsgi_req->remote_addr_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "remote_addr", zero);
+	Py_DECREF(zero);
+
+	zero = PyString_FromStringAndSize(wsgi_req->path_info, wsgi_req->path_info_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "uri", zero);
+	Py_DECREF(zero);
+
+	if (wsgi_req->query_string_len > 0) {
+		zero = PyString_FromStringAndSize(wsgi_req->query_string, wsgi_req->query_string_len);
+		PyDict_SetItemString(wsgi_req->async_environ, "query_string", zero);
+		Py_DECREF(zero);
+	}
+
+	zero = PyString_FromStringAndSize(uwsgi_lower(wsgi_req->method, wsgi_req->method_len), wsgi_req->method_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "method", zero);
+	Py_DECREF(zero);
+
+	if (wsgi_req->post_cl > 0) {
+		PyDict_SetItemString(wsgi_req->async_environ, "content_length", PyInt_FromLong(wsgi_req->post_cl));
+		if (wsgi_req->content_type_len > 0) {
+			zero = PyString_FromStringAndSize(wsgi_req->content_type, wsgi_req->content_type_len);
+                	PyDict_SetItemString(wsgi_req->async_environ, "content_type", zero);
+                	Py_DECREF(zero);
+		}
+	}
+
+
+
+	PyObject *headers = PyDict_New();
+
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                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
+		if (wsgi_req->hvec[i].iov_len < 6) continue;
+		if (!uwsgi_startswith(wsgi_req->hvec[i].iov_base, "HTTP_", 5)) {
+			(void) uwsgi_lower(wsgi_req->hvec[i].iov_base+5, wsgi_req->hvec[i].iov_len-5);
+#ifdef PYTHREE
+                	pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base+5, wsgi_req->hvec[i].iov_len-5, 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+5, wsgi_req->hvec[i].iov_len-5);
+                	pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
+#endif
+			PyObject *old_value = PyDict_GetItem(headers, pydictkey);
+			if (old_value) {
+				if (PyString_Check(old_value)) {
+					PyObject *new_value = PyList_New(0);
+					PyList_Append(new_value, old_value);
+					old_value = new_value;
+                			PyDict_SetItem(headers, pydictkey, old_value);
+					Py_DECREF(old_value);
+				}
+				PyList_Append(old_value, pydictvalue);
+			}
+			else {
+                		PyDict_SetItem(headers, pydictkey, pydictvalue);
+			}
+                	Py_DECREF(pydictkey);
+                	Py_DECREF(pydictvalue);
+		}
+        }
+
+	PyDict_SetItemString(wsgi_req->async_environ, "headers", headers);
+	Py_DECREF(headers);
+
+        // 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), "pump_body", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "pump_body", "r", NULL);
+#endif
+        }
+        else {
+                // 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;
+
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "body", wsgi_req->async_input);
+
+
+	if (wsgi_req->scheme_len > 0) {
+		zero = PyString_FromStringAndSize(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') {
+			zero = PyString_FromString("https");
+		}
+		else {
+			zero = PyString_FromString("http");
+		}
+	}
+	else {
+		zero = PyString_FromString("http");
+	}
+	PyDict_SetItemString(wsgi_req->async_environ, "scheme", zero);
+	Py_DECREF(zero);
+
+
+	wsgi_req->async_app = wi->callable;
+
+	// export .env only in non-threaded mode
+        if (uwsgi.threads < 2) {
+        	PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
+
+        if (uwsgi.cores > 1) {
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+        }
+
+        // cache this ?
+        if (uwsgi.cluster_fd >= 0) {
+                zero = PyString_FromString(uwsgi.cluster);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
+                Py_DECREF(zero);
+                zero = PyString_FromString(uwsgi.hostname);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster_node", zero);
+                Py_DECREF(zero);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
+
+
+	// call
+
+	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions, wsgi_req);
+}
+
+
+int uwsgi_response_subhandler_pump(struct wsgi_request *wsgi_req) {
+
+	PyObject *pychunk;
+	ssize_t wsize;
+	int i;
+
+	struct http_status_codes *http_sc;
+	char sc[4];
+
+	UWSGI_GET_GIL
+
+	// ok its a yield
+	if (!wsgi_req->async_placeholder) {
+		if (PyDict_Check((PyObject *)wsgi_req->async_result)) {
+
+
+			PyObject *status = PyDict_GetItemString((PyObject *)wsgi_req->async_result, "status");
+			if (!status) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			PyObject *headers = PyDict_GetItemString((PyObject *)wsgi_req->async_result, "headers");
+			if (!headers) {
+				uwsgi_log("invalid Pump response (headers).\n"); 
+				goto clear; 
+			}
+
+
+			wsgi_req->async_placeholder =  PyDict_GetItemString((PyObject *)wsgi_req->async_result, "body");
+			if (!wsgi_req->async_placeholder) {
+				uwsgi_log("invalid Pump response (body).\n"); 
+				goto clear; 
+			}
+
+			// get the status code
+			if (!PyInt_Check(status)) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			if (uwsgi_num2str2n(PyInt_AsLong(status), sc, 4) != 3) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			int found = 0;
+			for (http_sc = hsc; http_sc->message != NULL; http_sc++) {
+                		if (http_sc->key[0] == sc[0] && http_sc->key[1] == sc[1] && http_sc->key[2] == sc[2]) {
+                        		wsgi_req->hvec[4].iov_base = (char *) http_sc->message;
+                        		wsgi_req->hvec[4].iov_len = http_sc->message_size;
+					found = 1;
+                        		break;
+                		}
+        		}
+		
+			if (!found) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			wsgi_req->hvec[0].iov_base = wsgi_req->protocol;
+			wsgi_req->hvec[0].iov_len = wsgi_req->protocol_len;
+			wsgi_req->hvec[1].iov_base = " ";
+			wsgi_req->hvec[1].iov_len = 1;
+			wsgi_req->hvec[2].iov_base = sc;
+			wsgi_req->hvec[2].iov_len = 3;
+			wsgi_req->hvec[3].iov_base = " ";
+			wsgi_req->hvec[3].iov_len = 1;
+			wsgi_req->hvec[5].iov_base = "\r\n";
+			wsgi_req->hvec[5].iov_len = 2;
+
+			UWSGI_RELEASE_GIL
+                	wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 6);
+                	UWSGI_GET_GIL
+                	if (wsize < 0) {
+                        	uwsgi_error("writev()");
+                	}
+                	wsgi_req->headers_size += wsize;
+
+			PyObject *hhkey, *hhvalue;
+#ifdef UWSGI_PYTHON_OLD
+			int hhpos = 0;
+#else
+			Py_ssize_t hhpos = 0;
+#endif
+			while (PyDict_Next(headers, &hhpos, &hhkey, &hhvalue)) {
+				if (!PyString_Check(hhkey)) continue;
+
+				wsgi_req->hvec[0].iov_base = PyString_AsString(hhkey);
+				wsgi_req->hvec[0].iov_len = PyString_Size(hhkey);	
+				((char*)wsgi_req->hvec[0].iov_base)[0] = toupper((int) ((char*)wsgi_req->hvec[0].iov_base)[0]);
+
+				wsgi_req->hvec[1].iov_base = ": ";
+                        	wsgi_req->hvec[1].iov_len = 2;
+
+				wsgi_req->hvec[3].iov_base = "\r\n";
+                        	wsgi_req->hvec[3].iov_len = 2;
+				if (PyList_Check(hhvalue)) {
+					for(i=0;i<PyList_Size(hhvalue);i++) {
+						PyObject *item = PyList_GetItem(hhvalue, i);
+						if (PyString_Check(item)) {
+							wsgi_req->hvec[2].iov_base = PyString_AsString(item);
+                                        		wsgi_req->hvec[2].iov_len = PyString_Size(item);
+                                        		UWSGI_RELEASE_GIL
+                                        		wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 4);
+                                        		UWSGI_GET_GIL
+                                        		if (wsize < 0) {
+                                                		uwsgi_error("writev()");
+                                        		}
+                                        		wsgi_req->headers_size += wsize;
+						}
+					}	
+				}
+				else if (PyString_Check(hhvalue)) {
+					wsgi_req->hvec[2].iov_base = PyString_AsString(hhvalue);
+                                	wsgi_req->hvec[2].iov_len = PyString_Size(hhvalue);
+					UWSGI_RELEASE_GIL
+                        		wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 4);
+                        		UWSGI_GET_GIL
+                        		if (wsize < 0) {
+                                		uwsgi_error("writev()");
+                        		}
+                        		wsgi_req->headers_size += wsize;
+				}
+			}
+
+			wsgi_req->socket->proto_write(wsgi_req, "\r\n", 2);
+			Py_INCREF((PyObject *)wsgi_req->async_placeholder);
+
+			if (PyString_Check((PyObject *)wsgi_req->async_placeholder)) {
+                		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(wsgi_req->async_placeholder), PyString_Size(wsgi_req->async_placeholder))) < 0) {
+                        		uwsgi_error("write()");
+                        		goto clear;
+                		}
+                		wsgi_req->response_size += wsize;
+                		goto clear;
+        		}
+#ifdef PYTHREE
+			else if ((wsgi_req->sendfile_fd = PyObject_AsFileDescriptor((PyObject *)wsgi_req->async_placeholder)) > -1) {
+#else
+			else if (PyFile_Check((PyObject *)wsgi_req->async_placeholder)) {
+				wsgi_req->sendfile_fd = fileno(PyFile_AsFile((PyObject *)wsgi_req->async_placeholder));
+#endif
+                		wsize = uwsgi_sendfile(wsgi_req);
+				if (wsize < 0) {
+					goto clear;
+				}
+                		wsgi_req->response_size += wsize;
+				goto clear;
+			}
+
+			PyObject *tmp = (PyObject *)wsgi_req->async_placeholder;
+
+			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_placeholder );
+
+			Py_DECREF(tmp);
+
+			if (!wsgi_req->async_placeholder) {
+				goto clear;
+			}
+#ifdef UWSGI_ASYNC
+			if (uwsgi.async > 1) {
+				UWSGI_RELEASE_GIL
+				return UWSGI_AGAIN;
+			}
+		}
+		else {
+			uwsgi_log("invalid Pump response.\n"); 
+			goto clear; 
+		}
+#endif
+	}
+
+
+
+	pychunk = PyIter_Next(wsgi_req->async_placeholder);
+
+	if (!pychunk) {
+		if (PyErr_Occurred()) PyErr_Print();
+		goto clear;
+	}
+
+
+	if (PyString_Check(pychunk)) {
+		if ((wsize = wsgi_req->socket->proto_write(wsgi_req,  PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
+			uwsgi_error("write()");
+			Py_DECREF(pychunk);
+			goto clear;
+		}
+		wsgi_req->response_size += wsize;
+	}
+
+
+	Py_DECREF(pychunk);
+	UWSGI_RELEASE_GIL
+	return UWSGI_AGAIN;
+
+clear:
+	if (wsgi_req->async_input) {
+                Py_DECREF((PyObject *)wsgi_req->async_input);
+        }
+	if (wsgi_req->async_environ) {
+		PyDict_Clear(wsgi_req->async_environ);
+	}
+	Py_XDECREF((PyObject *)wsgi_req->async_placeholder);
+
+	Py_DECREF((PyObject *)wsgi_req->async_result);
+	PyErr_Clear();
+
+	UWSGI_RELEASE_GIL
+	return UWSGI_OK;
+}
+

plugins/python/pyloader.c

@@ -22,12 +22,62 @@ PyMethodDef uwsgi_eventfd_read_method[] = { {"uwsgi_eventfd_read", py_eventfd_re
 PyMethodDef uwsgi_eventfd_write_method[] = { {"uwsgi_eventfd_write", py_eventfd_write, METH_VARARGS, ""}};
 #endif
 
-int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter) {
+#ifdef UWSGI_MINTERPRETERS
+
+void set_dyn_pyhome(char *home, uint16_t pyhome_len) {
+
+
+	char venv_version[15];
+	PyObject *site_module;
+
+	PyObject *pysys_dict = get_uwsgi_pydict("sys");
+
+	PyObject *pypath = pypath = PyDict_GetItemString(pysys_dict, "path");
+	if (!pypath) {
+		PyErr_Print();
+		exit(1);
+	}
+
+        // simulate a pythonhome directive
+        if (uwsgi.wsgi_req->pyhome_len > 0) {
+
+                PyObject *venv_path = UWSGI_PYFROMSTRINGSIZE(uwsgi.wsgi_req->pyhome, uwsgi.wsgi_req->pyhome_len);
+
+#ifdef UWSGI_DEBUG
+                uwsgi_debug("setting dynamic virtualenv to %.*s\n", uwsgi.wsgi_req->pyhome_len, uwsgi.wsgi_req->pyhome);
+#endif
+
+                PyDict_SetItemString(pysys_dict, "prefix", venv_path);
+                PyDict_SetItemString(pysys_dict, "exec_prefix", venv_path);
+
+                venv_version[14] = 0;
+                if (snprintf(venv_version, 15, "/lib/python%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION) == -1) {
+                        return;
+                }
+
+                // check here
+                PyString_Concat(&venv_path, PyString_FromString(venv_version));
+
+                if (PyList_Insert(pypath, 0, venv_path)) {
+                        PyErr_Print();
+                }
+
+                site_module = PyImport_ImportModule("site");
+                if (site_module) {
+                        PyImport_ReloadModule(site_module);
+                }
+
+        }
+}
+
+#endif
+
+
+int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter, int app_type) {
 
-	PyObject *zero;
 	PyObject *app_list = NULL, *applications = NULL;
 
-	int id = uwsgi.apps_cnt;
+	int id = uwsgi_apps_cnt;
 	int multiapp = 0;
 
 #ifdef UWSGI_ASYNC
@@ -39,23 +89,7 @@ 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 = "";
-	}
-	else if (wsgi_req->script_name_len == 1) {
-		if (wsgi_req->script_name[0] == '/') {
-			wsgi_req->script_name = "";
-			wsgi_req->script_name_len = 0;
-		}
-	}
-
-
-	if (uwsgi.vhost && wsgi_req->host_len > 0) {
-		mountpoint = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|", 1, wsgi_req->script_name, wsgi_req->script_name_len);
-	}
-	else {
-		mountpoint = uwsgi_strncopy(wsgi_req->script_name, wsgi_req->script_name_len);
-	}
+	mountpoint = uwsgi_strncopy(wsgi_req->appid, wsgi_req->appid_len);
 
 	if (uwsgi_get_app_id(mountpoint, strlen(mountpoint), -1) != -1) {
 		uwsgi_log( "mountpoint %.*s already configured. skip.\n", strlen(mountpoint), mountpoint);
@@ -64,7 +98,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 
 
-	wi = &uwsgi.apps[id];
+	wi = &uwsgi_apps[id];
 
 	memset(wi, 0, sizeof(struct uwsgi_app));
 	wi->mountpoint = mountpoint;
@@ -111,10 +145,11 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
                                 		continue;
                         		}
 	
+#ifdef UWSGI_DEBUG
 					uwsgi_log("%s = %s\n", PyString_AsString(k), PyString_AsString(env_value));
+#endif
 
                         		if (PyObject_SetItem(py_environ, k, env_value)) {
-						uwsgi_log("cazzo\n");
                                 		PyErr_Print();
                         		}
 
@@ -127,7 +162,9 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
         	}
 	}
 
+#ifdef UWSGI_MINTERPRETERS
 	if (interpreter == NULL && id) {
+
 		wi->interpreter = Py_NewInterpreter();
 		if (!wi->interpreter) {
 			uwsgi_log( "unable to initialize the new python interpreter\n");
@@ -150,6 +187,13 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		wi->interpreter = up.main_thread;
 	}
 
+	if (wsgi_req->pyhome_len) {
+		set_dyn_pyhome(wsgi_req->pyhome, wsgi_req->pyhome_len);
+	}
+#else
+	wi->interpreter = up.main_thread;
+#endif
+
 	if (wsgi_req->touch_reload_len) {
 		struct stat trst;
 		char *touch_reload = uwsgi_strncopy(wsgi_req->touch_reload, wsgi_req->touch_reload_len);
@@ -162,7 +206,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	wi->callable = up.loaders[loader](arg1);
 
 	if (!wi->callable) {
-		uwsgi_log("unable to load app SCRIPT_NAME=%s\n", mountpoint);
+		uwsgi_log("unable to load app %d (mountpoint='%s') (callable not found or import error)\n", id, mountpoint);
 		goto doh;
 	}
 
@@ -186,12 +230,22 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		}
 		wi->mountpoint = PyString_AsString(app_mnt);
 		wi->mountpoint_len = strlen(wi->mountpoint);
-		wsgi_req->script_name = wi->mountpoint;
-		wsgi_req->script_name_len = wi->mountpoint_len;
+		wsgi_req->appid = wi->mountpoint;
+		wsgi_req->appid_len = wi->mountpoint_len;
+#ifdef UWSGI_DEBUG
 		uwsgi_log("main mountpoint = %s\n", wi->mountpoint);
+#endif
 		wi->callable = PyDict_GetItem(applications, app_mnt);
+		if (PyString_Check((PyObject *) wi->callable)) {
+			PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+			if (callables_dict) {
+				wi->callable = PyDict_GetItem(callables_dict, (PyObject *)wi->callable);	
+			}
+		}
 	}
 
+	Py_INCREF((PyObject *)wi->callable);
+
 #ifdef UWSGI_ASYNC
 	wi->environ = malloc(sizeof(PyObject*)*uwsgi.cores);
 	if (!wi->environ) {
@@ -214,47 +268,29 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #endif
 
-	// check function args
-	// by defaut it is a WSGI app
-	wi->argc = 2;
-	zero = PyObject_GetAttrString(wi->callable, "__code__");
-	if (!zero) {
-		zero = PyObject_GetAttrString(wi->callable, "__call__");
-		if (zero) {
-			zero = PyObject_GetAttrString(wi->callable, "__code__");
-		}
-		else {
-			uwsgi_log("WARNING: unable to get the number of callable args. Fallback to WSGI\n");
-		}
-	}
+	wi->argc = 1;
 
-	// avoid __code__ attr error propagation
-	PyErr_Clear();
-
-	if (zero) {
-		zero = PyObject_GetAttrString(zero, "co_argcount");
-		wi->argc = (int) PyInt_AsLong(zero);
-	}
-
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("-- WSGI callable detected --\n");
+		uwsgi_log("-- WSGI callable selected --\n");
 #endif
 		wi->request_subhandler = uwsgi_request_subhandler_wsgi;
 		wi->response_subhandler = uwsgi_response_subhandler_wsgi;
+		wi->argc = 2;
 	}
-#ifdef UWSGI_WEB3
-	else if (wi->argc == 1) {
+	else if (app_type == PYTHON_APP_TYPE_WEB3) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("-- Web3 callable detected --\n");
+		uwsgi_log("-- Web3 callable selected --\n");
 #endif
 		wi->request_subhandler = uwsgi_request_subhandler_web3;
 		wi->response_subhandler = uwsgi_response_subhandler_web3;
 	}
+	else if (app_type == PYTHON_APP_TYPE_PUMP) {
+#ifdef UWSGI_DEBUG
+		uwsgi_log("-- Pump callable selected --\n");
 #endif
-	else {
-		uwsgi_log("-- INVALID callable detected --\n");
-		goto doh;
+		wi->request_subhandler = uwsgi_request_subhandler_pump;
+		wi->response_subhandler = uwsgi_response_subhandler_pump;
 	}
 
 #ifdef UWSGI_ASYNC
@@ -272,7 +308,8 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		}
 
 		// add start_response on WSGI app
-		if (wi->argc == 2) {
+		Py_INCREF((PyObject *)up.wsgi_spitout);
+		if (app_type == PYTHON_APP_TYPE_WSGI) {
 			if (PyTuple_SetItem(wi->args[i], 1, up.wsgi_spitout)) {
 				uwsgi_log("unable to set start_response in args tuple\n");
 				exit(1);
@@ -281,8 +318,10 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #else
 
+	// add start_response on WSGI app
+	Py_INCREF((PyObject *)up.wsgi_spitout);
 	wi->wsgi_args = PyTuple_New(wi->argc);
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 		if (PyTuple_SetItem(wi->wsgi_args, 1, up.wsgi_spitout)) {
 			uwsgi_log("unable to set start_response in args tuple\n");
 			exit(1);
@@ -290,7 +329,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #endif
 
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 #ifdef UWSGI_SENDFILE
 		// prepare sendfile() for WSGI app
 		wi->sendfile = PyCFunction_New(uwsgi_sendfile_method, NULL);
@@ -302,9 +341,23 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 #endif
 	}
 
+	// cache most used values
+
+	wi->gateway_version = PyTuple_New(2);
+        PyTuple_SetItem(wi->gateway_version, 0, PyInt_FromLong(1));
+        PyTuple_SetItem(wi->gateway_version, 1, PyInt_FromLong(0));
+	Py_INCREF((PyObject *)wi->gateway_version);
+
+	wi->uwsgi_version = PyString_FromString(UWSGI_VERSION);
+	Py_INCREF((PyObject *)wi->uwsgi_version);
+
+	wi->uwsgi_node = PyString_FromString(uwsgi.hostname);
+	Py_INCREF((PyObject *)wi->uwsgi_node);
+
 	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);
@@ -317,19 +370,22 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		PyThreadState_Swap(up.main_thread);
 	}
 
-	if (wi->argc == 1) {
-		uwsgi_log( "Web3 application %d (SCRIPT_NAME=%.*s) ready on interpreter %p", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter);
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
+		uwsgi_log( "WSGI application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
-	else {
-		uwsgi_log( "WSGI application %d (SCRIPT_NAME=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+	else if (app_type == PYTHON_APP_TYPE_WEB3) {
+		uwsgi_log( "Web3 application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+	}
+	else if (app_type == PYTHON_APP_TYPE_PUMP) {
+		uwsgi_log( "Pump application %d (mountpoint='%.*s') ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 
-	if (!wsgi_req->script_name_len) {
+	if ((wsgi_req->appid_len == 0 || (wsgi_req->appid_len = 1 && wsgi_req->appid[0] == '/')) && uwsgi.default_app == -1) {
 		uwsgi_rawlog(" (default app)");
 		uwsgi.default_app = id;
 	}
 
-	uwsgi.apps_cnt++;
+	uwsgi_apps_cnt++;
 
 	uwsgi_rawlog("\n");
 
@@ -341,9 +397,29 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 				continue;
 			}
 
-			wsgi_req->script_name = PyString_AsString(app_mnt);
-			wsgi_req->script_name_len = strlen(wsgi_req->script_name);
-			init_uwsgi_app(LOADER_CALLABLE, PyDict_GetItem(applications, app_mnt), wsgi_req, wi->interpreter);
+			wsgi_req->appid = PyString_AsString(app_mnt);
+			wsgi_req->appid_len = strlen(wsgi_req->appid);
+			PyObject *a_callable = PyDict_GetItem(applications, app_mnt);
+			if (PyString_Check(a_callable)) {
+
+				PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+				if (callables_dict) {
+					a_callable = PyDict_GetItem(callables_dict, a_callable);
+				}
+			}
+			if (!a_callable) {
+				uwsgi_log("skipping broken app %s\n", wsgi_req->appid);
+				continue;
+			}
+			init_uwsgi_app(LOADER_CALLABLE, a_callable, wsgi_req, wi->interpreter, app_type);
+		}
+	}
+
+	// check if we need to emulate fork() COW
+	if (uwsgi.mywid == 0) {
+		for(i=1;i<=uwsgi.numproc;i++) {
+			memcpy(&uwsgi.workers[i].apps[id], &uwsgi.workers[0].apps[id], sizeof(struct uwsgi_app));
+			uwsgi.workers[i].apps_cnt = uwsgi_apps_cnt;
 		}
 	}
 
@@ -352,6 +428,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 doh:
 	free(mountpoint);
 	PyErr_Print();
+#ifdef UWSGI_MINTERPRETERS
 	if (interpreter == NULL && id) {
 		Py_EndInterpreter(wi->interpreter);
 		if (uwsgi.threads > 1) {
@@ -361,6 +438,7 @@ doh:
 			PyThreadState_Swap(up.main_thread);
 		}
 	}
+#endif
 	return -1;
 }
 
@@ -405,7 +483,9 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 
 	PyObject *tmp_callable;
 	PyObject *applications;
+#ifndef UWSGI_PYPY
 	PyObject *uwsgi_dict = get_uwsgi_pydict("uwsgi");
+#endif
 
 	char *module = (char *) arg1;
 
@@ -428,8 +508,10 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 		return NULL;
 	}
 
+#ifndef UWSGI_PYPY
 	applications = PyDict_GetItemString(uwsgi_dict, "applications");
 	if (applications && PyDict_Check(applications)) return applications;
+#endif
 
 
 	applications = PyDict_GetItemString(wsgi_dict, "applications");
@@ -440,9 +522,9 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 	if (quick_callable[strlen(quick_callable) -2 ] == '(' && quick_callable[strlen(quick_callable) -1] ==')') {
 		quick_callable[strlen(quick_callable) -2 ] = 0;
 		tmp_callable = PyDict_GetItemString(wsgi_dict, quick_callable);
-		quick_callable[strlen(quick_callable) -2 ] = '(';
+		quick_callable[strlen(quick_callable)] = '(';
 		if (tmp_callable) {
-			return python_call(tmp_callable, PyTuple_New(0), 0);
+			return python_call(tmp_callable, PyTuple_New(0), 0, NULL);
 		}
 	}
 
@@ -521,8 +603,14 @@ PyObject *uwsgi_file_loader(void *arg1) {
 	PyObject *wsgi_file_module, *wsgi_file_dict;
 	PyObject *wsgi_file_callable;
 
-	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
+	char *callable = up.callable;
+	if (!callable) callable = "application";
+
+	wsgi_file_module = uwsgi_pyimport_by_filename(uwsgi_concat2("uwsgi_file_", uwsgi_pythonize(filename)), filename);
+	if (!wsgi_file_module) {
+		PyErr_Print();
+		exit(1);
+	}
 
 	wsgi_file_dict = PyModule_GetDict(wsgi_file_module);
 	if (!wsgi_file_dict) {
@@ -530,7 +618,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);
@@ -594,6 +682,8 @@ PyObject *uwsgi_paste_loader(void *arg1) {
 
 PyObject *uwsgi_eval_loader(void *arg1) {
 
+#ifndef UWSGI_PYPY
+
 	char *code = (char *) arg1;
 
 	PyObject *wsgi_eval_module, *wsgi_eval_callable = NULL;
@@ -649,6 +739,9 @@ PyObject *uwsgi_eval_loader(void *arg1) {
 	}
 
 	return wsgi_eval_callable;
+#else
+	return NULL;
+#endif
 
 }
 

plugins/python/pyutils.c

@@ -8,17 +8,27 @@ int manage_python_response(struct wsgi_request *wsgi_req) {
 	return uwsgi_response_subhandler_wsgi(wsgi_req);
 }
 
-PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
+PyObject *python_call(PyObject *callable, PyObject *args, int catch, struct wsgi_request *wsgi_req) {
 
 	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");
 		}
-		uwsgi.workers[uwsgi.mywid].exceptions++;
+		// this can be in a spooler or in the master
+		if (uwsgi.mywid > 0) {
+			uwsgi.workers[uwsgi.mywid].exceptions++;
+			if (wsgi_req) {
+				uwsgi_apps[wsgi_req->app_id].exceptions++;
+			}
+		}
 		if (!catch) {
 			PyErr_Print();
 		}
@@ -35,7 +45,7 @@ PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
 
 int uwsgi_python_call(struct wsgi_request *wsgi_req, PyObject *callable, PyObject *args) {
 
-	wsgi_req->async_result = python_call(callable, args, 0);
+	wsgi_req->async_result = python_call(callable, args, 0, wsgi_req);
 
 	if (wsgi_req->async_result) {
 		while ( manage_python_response(wsgi_req) != UWSGI_OK) {
@@ -62,8 +72,9 @@ void init_pyargv() {
 	up.py_argv[0] = "uwsgi";
 #endif
 
-	if (up.argv != NULL && !up.argc) {
-		up.argc++;
+	up.argc = 1;
+
+	if (up.argv != NULL) {
 #ifdef PYTHREE
 		wchar_t *wcargv = malloc( sizeof( wchar_t ) * (strlen(up.argv)+1));
 		if (!wcargv) {
@@ -94,7 +105,20 @@ void init_pyargv() {
 			}
 		}
 
+#ifndef UWSGI_PYPY
 		PySys_SetArgv(up.argc, up.py_argv);
+#endif
+
+	PyObject *sys_dict = get_uwsgi_pydict("sys");
+	if (!sys_dict) {
+		uwsgi_log("unable to load python sys module !!!\n");
+		exit(1);
+	}
+#ifdef PYTHREE
+	PyDict_SetItemString(sys_dict, "executable", PyUnicode_FromString(uwsgi.binary_path));
+#else
+	PyDict_SetItemString(sys_dict, "executable", PyString_FromString(uwsgi.binary_path));
+#endif
 
 
 }

plugins/python/symimporter.c

@@ -0,0 +1,762 @@
+#include "uwsgi_python.h"
+
+#if !defined(PYTHREE) && !defined(UWSGI_PYPY)
+
+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},
+	{ NULL, NULL },
+};
+
+static PyMethodDef symzipimporter_methods[] = {
+	{"find_module", symzipimporter_find_module, METH_VARARGS},
+	{"load_module", symzipimporter_load_module, METH_VARARGS},
+	{ NULL, NULL },
+};
+
+static void uwsgi_symimporter_free(struct _symimporter *self) {
+	PyObject_Del(self);
+}
+
+
+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 */
+    0,                            /* tp_free */
+};
+
+static int
+zipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
+{
+
+
+        char *name;
+        char *prefix = NULL;
+	int len = 0;
+
+        if (!PyArg_ParseTuple(args, "s", &name))
+                return -1;
+
+        // avoid GC !!!
+        name = uwsgi_concat2(name, "");
+
+	if (uwsgi_check_scheme(name)) {
+                prefix = uwsgi_get_last_char(name, '/');
+                prefix = uwsgi_get_last_char(prefix, ':');
+        }
+        else {
+                prefix = uwsgi_get_last_char(name, ':');
+        }
+
+	if (prefix) {
+		prefix[0] = 0;
+	}
+
+
+	char *body = uwsgi_open_and_read(name, &len, 0, NULL);
+	if (!body) {
+		return -1;
+	}
+
+
+
+	PyObject *stringio = PyImport_ImportModule("StringIO");
+        if (!stringio) {
+                return -1;
+        }
+
+
+        PyObject *stringio_dict = PyModule_GetDict(stringio);
+        if (!stringio_dict) {
+                return -1;
+        }
+
+
+        PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
+        if (!stringio_stringio) {
+                return -1;
+        }
+
+
+        PyObject *stringio_args = PyTuple_New(1);
+        PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(body, len));
+
+
+        PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+        if (!source_code) {
+                return -1;
+        }
+
+
+        PyObject *zipfile = PyImport_ImportModule("zipfile");
+
+        if (!zipfile) {
+		PyErr_Print();
+                return -1;
+        }
+
+
+        PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+        if (!zipfile_dict) {
+                return -1;
+        }
+
+        PyObject *zipfile_zipfile = PyDict_GetItemString(zipfile_dict, "ZipFile");
+        if (!zipfile_zipfile) {
+                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) {
+                return -1;
+        }
+
+        Py_INCREF(self->zip);
+
+        self->items = PyObject_CallMethod(self->zip, "namelist", NULL);
+        if (!self->items) {
+                return -1;
+        }
+
+        Py_INCREF(self->items);
+
+        self->prefix = NULL;
+        if (prefix) {
+                self->prefix = prefix+1;
+                prefix[0] = ':';
+        }
+
+
+        return 0;
+}
+
+
+
+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) {
+		return -1;
+	}
+
+	PyObject *stringio_dict = PyModule_GetDict(stringio);
+	if (!stringio_dict) {
+		return -1;
+	}
+
+	PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
+	if (!stringio_stringio) {
+		return -1;
+	}
+
+	PyObject *stringio_args = PyTuple_New(1);
+	PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(code_start, code_end-code_start));
+
+	PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+	if (!source_code) {
+		return -1;
+	}
+
+	PyObject *zipfile = PyImport_ImportModule("zipfile");
+	if (!zipfile) {
+		return -1;
+	}
+	
+	PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+        if (!zipfile_dict) {
+                return -1;
+        }
+
+        PyObject *zipfile_zipfile = PyDict_GetItemString(zipfile_dict, "ZipFile");
+        if (!zipfile_zipfile) {
+                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) {
+                return -1;
+        }
+
+	Py_INCREF(self->zip);
+
+	self->items = PyObject_CallMethod(self->zip, "namelist", NULL);
+        if (!self->items) {
+                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 */
+    0,                            /* tp_free */
+};
+
+static PyTypeObject ZipImporter_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "uwsgi.ZipImporter",
+    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 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) zipimporter_init,                 /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
+    0,                            /* 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(&ZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize zip 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);
+	}
+
+	Py_INCREF((PyObject *)&SymImporter_Type);
+	if (PyModule_AddObject(uwsgi_em, "SymbolsImporter",
+                           (PyObject *)&SymImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols importer object\n");
+		exit(1);
+	}
+
+	Py_INCREF((PyObject *)&ZipImporter_Type);
+	if (PyModule_AddObject(uwsgi_em, "ZipImporter",
+                           (PyObject *)&ZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize zip importer object\n");
+		exit(1);
+	}
+
+	Py_INCREF((PyObject *)&SymZipImporter_Type);
+	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_python.h

@@ -13,15 +13,34 @@
 #define LONG_ARGS_PYARGV                LONG_ARGS_PYTHON_BASE + 3
 #define LONG_ARGS_PYMODULE_ALIAS        LONG_ARGS_PYTHON_BASE + 4
 #define LONG_ARGS_RELOAD_OS_ENV		LONG_ARGS_PYTHON_BASE + 5
+#define LONG_ARGS_PYIMPORT		LONG_ARGS_PYTHON_BASE + 6
+#define LONG_ARGS_POST_PYMODULE_ALIAS   LONG_ARGS_PYTHON_BASE + 7
+#define LONG_ARGS_WEB3			LONG_ARGS_PYTHON_BASE + 8
+#define LONG_ARGS_PUMP			LONG_ARGS_PYTHON_BASE + 9
+#define LONG_ARGS_WSGI_LITE		LONG_ARGS_PYTHON_BASE + 10
+#define LONG_ARGS_PYSHELL		LONG_ARGS_PYTHON_BASE + 11
+#define LONG_ARGS_SPOOLER_PYIMPORT	LONG_ARGS_PYTHON_BASE + 12
+#define LONG_ARGS_PYTHON_RUN		LONG_ARGS_PYTHON_BASE + 13
+
+#define PYTHON_APP_TYPE_WSGI		0
+#define PYTHON_APP_TYPE_WEB3		1
+#define PYTHON_APP_TYPE_WSGI2		2
+#define PYTHON_APP_TYPE_PUMP		3
+#define PYTHON_APP_TYPE_WSGI_LITE	4
 
 #if PY_MINOR_VERSION == 4 && PY_MAJOR_VERSION == 2
 #define Py_ssize_t ssize_t
+#define UWSGI_PYTHON_OLD
 #endif
 
 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 7
 #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
@@ -56,10 +75,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
@@ -73,6 +96,18 @@ PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t);
 
 #define LOADER_MAX              8
 
+#define UWSGI_PY_READLINE_BUFSIZE 1024
+
+typedef struct uwsgi_Input {
+        PyObject_HEAD
+        char readline[UWSGI_PY_READLINE_BUFSIZE];
+        size_t readline_size;
+        size_t readline_max_size;
+        size_t readline_pos;
+        size_t pos;
+        struct wsgi_request *wsgi_req;
+} uwsgi_Input;
+
 struct uwsgi_python {
 
 	char *home;
@@ -94,7 +129,12 @@ struct uwsgi_python {
 
 	char *test_module;
 
+	int pyshell;
+
 	struct uwsgi_string_list *python_path;
+	struct uwsgi_string_list *import_list;
+	struct uwsgi_string_list *spooler_import_list;
+	struct uwsgi_string_list *post_pymodule_alias;
 
 	PyObject *loader_dict;
 	PyObject* (*loaders[LOADER_MAX]) (void *);
@@ -104,6 +144,9 @@ struct uwsgi_python {
 	char *paste;
 	char *eval;
 
+	char *web3;
+	char *pump;
+	char *wsgi_lite;
 
 	char *callable;
 
@@ -140,6 +183,7 @@ struct uwsgi_python {
 	void (*extension)(void);
 
 	int reload_os_env;
+
 };
 
 
@@ -153,7 +197,7 @@ void uwsgi_paste_config(char *);
 void uwsgi_file_config(char *);
 void uwsgi_eval_config(char *);
 
-int init_uwsgi_app(int, void *, struct wsgi_request *wsgi_req, PyThreadState *);
+int init_uwsgi_app(int, void *, struct wsgi_request *, PyThreadState *, int);
 
 
 PyObject *py_eventfd_read(PyObject *, PyObject *);
@@ -162,7 +206,7 @@ PyObject *py_eventfd_write(PyObject *, PyObject *);
 
 int manage_python_response(struct wsgi_request *);
 int uwsgi_python_call(struct wsgi_request *, PyObject *, PyObject *);
-PyObject *python_call(PyObject *, PyObject *, int);
+PyObject *python_call(PyObject *, PyObject *, int, struct wsgi_request *);
 
 #ifdef UWSGI_SENDFILE
 PyObject *py_uwsgi_sendfile(PyObject *, PyObject *);
@@ -175,10 +219,11 @@ PyObject *py_uwsgi_spit(PyObject *, PyObject *);
 
 void init_pyargv(void);
 
-#ifdef UWSGI_WEB3
 void *uwsgi_request_subhandler_web3(struct wsgi_request *, struct uwsgi_app *);
 int uwsgi_response_subhandler_web3(struct wsgi_request *);
-#endif
+
+void *uwsgi_request_subhandler_pump(struct wsgi_request *, struct uwsgi_app *);
+int uwsgi_response_subhandler_pump(struct wsgi_request *);
 
 PyObject *uwsgi_uwsgi_loader(void *);
 PyObject *uwsgi_dyn_loader(void *);
@@ -208,6 +253,7 @@ void init_uwsgi_module_spooler(PyObject *);
 void init_uwsgi_module_sharedarea(PyObject *);
 void init_uwsgi_module_cache(PyObject *);
 void init_uwsgi_module_queue(PyObject *);
+void init_uwsgi_module_snmp(PyObject *);
 
 PyObject *uwsgi_pyimport_by_filename(char *, char *);
 
@@ -217,3 +263,19 @@ 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);
+
+char *uwsgi_pythonize(char *);
+
+#ifdef UWSGI_PYPY
+#undef UWSGI_MINTERPRETERS
+#endif
+
+#define uwsgi_pyexit {PyErr_Print();exit(1);}
+
+#ifdef __linux__
+#ifndef PYTHREE
+int uwsgi_init_symbol_import(void);
+#endif
+#endif

plugins/python/uwsgiplugin.py

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

plugins/python/web3_subhandler.c

@@ -1,20 +1,70 @@
-#include "uwsgi.h"
+#include "uwsgi_python.h"
 
 extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
 
 void *uwsgi_request_subhandler_web3(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
 
-	PyObject *zero, *wsgi_socket;
+	PyObject *zero;
 
-	wsgi_socket = PyFile_FromFile(wsgi_req->async_post, "web3_input", "r", NULL);
-	PyDict_SetItemString(wsgi_req->async_environ, "web3.input", wsgi_socket);
-	Py_DECREF(wsgi_socket);
+	int i;
+        PyObject *pydictkey, *pydictvalue;
+        char *path_info;
 
-	zero = PyTuple_New(2);
-	PyTuple_SetItem(zero, 0, PyInt_FromLong(1));
-	PyTuple_SetItem(zero, 1, PyInt_FromLong(0));
-	PyDict_SetItemString(wsgi_req->async_environ, "web3.version", zero);
-	Py_DECREF(zero);
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                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, 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);
+#endif
+                PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
+                Py_DECREF(pydictkey);
+                Py_DECREF(pydictvalue);
+        }
+
+        if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
+                wsgi_req->uh.modifier1 = 0;
+                pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
+                if (pydictkey) {
+                        if (PyString_Check(pydictkey)) {
+                                pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
+                                if (pydictvalue) {
+                                        if (PyString_Check(pydictvalue)) {
+                                                path_info = PyString_AsString(pydictvalue);
+                                                PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
+                                        }
+                                }
+                        }
+                }
+        }
+
+        // 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), "web3_input", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "web3_input", "r", NULL);
+#endif
+        }
+        else {
+                // 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;
+
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "web3.input", wsgi_req->async_input);
+
+	PyDict_SetItemString(wsgi_req->async_environ, "web3.version", wi->gateway_version);
 
 	zero = PyFile_FromFile(stderr, "web3_input", "w", NULL);
 	PyDict_SetItemString(wsgi_req->async_environ, "web3.errors", zero);
@@ -31,35 +81,53 @@ void *uwsgi_request_subhandler_web3(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 
 	if (wsgi_req->scheme_len > 0) {
-		zero = PyString_FromStringAndSize(wsgi_req->scheme, wsgi_req->scheme_len);
+		zero = UWSGI_PYFROMSTRINGSIZE(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') {
-			zero = PyString_FromString("https");
+			zero = UWSGI_PYFROMSTRING("https");
 		}
 		else {
-			zero = PyString_FromString("http");
+			zero = UWSGI_PYFROMSTRING("http");
 		}
 	}
 	else {
-		zero = PyString_FromString("http");
+		zero = UWSGI_PYFROMSTRING("http");
 	}
 	PyDict_SetItemString(wsgi_req->async_environ, "web3.url_scheme", zero);
 	Py_DECREF(zero);
 
 
-	wsgi_req->async_app = wi->wsgi_callable;
+	wsgi_req->async_app = wi->callable;
 
-	PyDict_SetItemString(uwsgi.embedded_dict, "env", wsgi_req->async_environ);
+	// export .env only in non-threaded mode
+        if (uwsgi.threads < 2) {
+        	PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
+        }
 
-	// TODO: fix this
-	//PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", uwsgi_version);
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
+
+        if (uwsgi.cores > 1) {
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+        }
+
+        // cache this ?
+        if (uwsgi.cluster_fd >= 0) {
+                zero = PyString_FromString(uwsgi.cluster);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
+                Py_DECREF(zero);
+                zero = PyString_FromString(uwsgi.hostname);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster_node", zero);
+                Py_DECREF(zero);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
 
 
 	// call
 
 	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
-	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions, wsgi_req);
 }
 
 
@@ -68,16 +136,7 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 	PyObject *pychunk;
 	ssize_t wsize;
 
-	// return or yield ? (PyString on python2 PyBytes on python3)
-	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) {
-			uwsgi_error("write()");
-			goto clear;
-		}
-		wsgi_req->response_size += wsize;
-		goto clear;
-	}
-
+	UWSGI_GET_GIL
 
 	// ok its a yield
 	if (!wsgi_req->async_placeholder) {
@@ -86,19 +145,51 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 				uwsgi_log("invalid Web3 response.\n"); 
 				goto clear; 
 			} 
-			if (py_uwsgi_spit(NULL, (PyObject *)wsgi_req->async_result) == Py_None) { 
+
+
+
+			wsgi_req->async_placeholder = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 0); 
+			Py_INCREF((PyObject *)wsgi_req->async_placeholder);
+
+			PyObject *spit_args = PyTuple_New(2);
+
+			PyObject *status = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 1);
+			Py_INCREF(status);
+			PyTuple_SetItem(spit_args, 0, status);
+
+			PyObject *headers = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 2);
+			Py_INCREF(headers);
+			PyTuple_SetItem(spit_args, 1, headers);
+
+			if (py_uwsgi_spit(NULL, spit_args) == Py_None) { 
+				Py_DECREF(spit_args);
 				goto clear; 
 			} 
 
-			wsgi_req->async_result = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 0); 
 
-			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_result );
+			Py_DECREF(spit_args);
+
+			if (PyString_Check((PyObject *)wsgi_req->async_placeholder)) {
+                		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(wsgi_req->async_placeholder), PyString_Size(wsgi_req->async_placeholder))) < 0) {
+                        		uwsgi_error("write()");
+                        		goto clear;
+                		}
+                		wsgi_req->response_size += wsize;
+                		goto clear;
+        		}
+
+			PyObject *tmp = (PyObject *)wsgi_req->async_placeholder;
+
+			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_placeholder );
+
+			Py_DECREF(tmp);
 
 			if (!wsgi_req->async_placeholder) {
-				goto clear2;
+				goto clear;
 			}
 #ifdef UWSGI_ASYNC
 			if (uwsgi.async > 1) {
+				UWSGI_RELEASE_GIL
 				return UWSGI_AGAIN;
 			}
 		}
@@ -119,9 +210,8 @@ int uwsgi_response_subhandler_web3(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;
@@ -131,34 +221,22 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 
 
 	Py_DECREF(pychunk);
+	UWSGI_RELEASE_GIL
 	return UWSGI_AGAIN;
 
 clear:
+	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/python/wsgi_handlers.c

@@ -4,16 +4,6 @@ extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
 
-typedef struct uwsgi_Input {
-        PyObject_HEAD
-	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) {
         Py_INCREF(self);
         return self;
@@ -44,8 +34,9 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
 				return res;
 			}
 		}
+		res = PyString_FromStringAndSize(ptr + self->readline_pos, self->readline_size - self->readline_pos);
 		self->readline_pos = 0;
-		return PyString_FromStringAndSize(ptr + self->readline_pos, self->readline_size - self->readline_pos);
+		return res;
 	}
 
 
@@ -55,13 +46,13 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
                 return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data");
         }
 
-	if (self->readline_max_size > 0 && self->readline_max_size < 1024) {
+	if (self->readline_max_size > 0 && self->readline_max_size < UWSGI_PY_READLINE_BUFSIZE) {
         	rlen = read(wsgi_req->poll.fd, self->readline, self->readline_max_size);
 	}
 	else {
-        	rlen = read(wsgi_req->poll.fd, self->readline, 1024);
+        	rlen = read(wsgi_req->poll.fd, self->readline, UWSGI_PY_READLINE_BUFSIZE);
 	}
-        if (rlen < 0) {
+        if (rlen <= 0) {
                 UWSGI_GET_GIL
                 return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
         }
@@ -74,7 +65,7 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
 
 	for(i=0;i<(size_t)rlen;i++) {
 		if (self->readline[i] == '\n') {
-			res = PyString_FromStringAndSize(self->readline, i);
+			res = PyString_FromStringAndSize(self->readline, i+1);
 			self->readline_pos+= i+1;
 			if (self->readline_pos >= self->readline_size) self->readline_pos = 0;
 			return res;
@@ -103,7 +94,7 @@ static void uwsgi_Input_free(uwsgi_Input *self) {
 static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 
 	long len = 0;
-	size_t remains;
+	size_t remains, tmp_pos = 0;
 	ssize_t rlen;
 	char *tmp_buf;
 	PyObject *res;
@@ -113,10 +104,24 @@ 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("");
 	}
 
+	// 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);
+	}
+
 	// return the whole input
         if (len <= 0) {
                 remains = self->wsgi_req->post_cl;
@@ -125,7 +130,7 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
                 remains = len ;
         }
 
-        if (remains + self->pos > self->wsgi_req->post_cl) {
+	if (remains + self->pos > self->wsgi_req->post_cl) {
                 remains = self->wsgi_req->post_cl - self->pos;
         }
 
@@ -134,7 +139,7 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
         }
 
 	if (uwsgi.post_buffering > 0) {
-		res = PyString_FromStringAndSize( self->wsgi_req->post_buffering_buf, remains);
+		res = PyString_FromStringAndSize( self->wsgi_req->post_buffering_buf+self->pos, remains);
 		self->pos += remains;
 		return res;
 	}
@@ -143,23 +148,26 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 
 	tmp_buf = uwsgi_malloc(remains);	
 
-	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");
+	while(remains) {
+		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(self->wsgi_req->poll.fd, tmp_buf+tmp_pos, remains);
+		if (rlen <= 0) {
+                       	free(tmp_buf);
+                       	UWSGI_GET_GIL
+                       	return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
+               	}
+		tmp_pos += rlen;
+		remains -= rlen;
 	}
 
-	rlen = read(self->wsgi_req->poll.fd, tmp_buf, remains);
-	if (rlen < 0) {
-		free(tmp_buf);
-		UWSGI_GET_GIL
-		return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
-	}
-
-	self->pos += rlen;
 	UWSGI_GET_GIL
-	res = PyString_FromStringAndSize(tmp_buf, rlen);
-
+	self->pos += tmp_pos;
+	res = PyString_FromStringAndSize(tmp_buf, tmp_pos);
 	free(tmp_buf);
 	return res;
 		
@@ -203,12 +211,18 @@ static PyObject *uwsgi_Input_close(uwsgi_Input *self, PyObject *args) {
 	return Py_None;
 }
 
+static PyObject *uwsgi_Input_fileno(uwsgi_Input *self, PyObject *args) {
+
+	return PyInt_FromLong(self->wsgi_req->poll.fd);
+}
+
 static PyMethodDef uwsgi_Input_methods[] = {
 	{ "read",      (PyCFunction)uwsgi_Input_read,      METH_VARARGS, 0 },
 	{ "readline",  (PyCFunction)uwsgi_Input_readline,  METH_VARARGS, 0 },
 	{ "readlines", (PyCFunction)uwsgi_Input_readlines, METH_VARARGS, 0 },
 // add close to allow mod_wsgi compatibility
 	{ "close",     (PyCFunction)uwsgi_Input_close,     METH_VARARGS, 0 },
+	{ "fileno",     (PyCFunction)uwsgi_Input_fileno,     METH_VARARGS, 0 },
 	{ NULL, NULL}
 };
 
@@ -309,16 +323,10 @@ PyObject *py_eventfd_write(PyObject * self, PyObject * args) {
 
 int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
-	int i;
-
-	PyObject *pydictkey, *pydictvalue;
-
-	char *path_info;
 	struct uwsgi_app *wi;
 
 	int tmp_stderr;
-	char *what;
-	int what_len;
+	int free_appid = 0;
 
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
@@ -345,7 +353,7 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 	/* Standard WSGI request */
 	if (!wsgi_req->uh.pktsize) {
-		uwsgi_log( "Invalid WSGI request. skip.\n");
+		uwsgi_log( "Empty python request. skip.\n");
 		return -1;
 	}
 
@@ -354,76 +362,59 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 
-	if (!up.ignore_script_name) {
-
-		if (!wsgi_req->script_name)
-			wsgi_req->script_name = "";
+	if (wsgi_req->appid_len == 0) {
+		if (!up.ignore_script_name) {
+			wsgi_req->appid = wsgi_req->script_name;
+			wsgi_req->appid_len = wsgi_req->script_name_len;
+		}
 
 		if (uwsgi.vhost) {
-			what = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|",1, wsgi_req->script_name, wsgi_req->script_name_len);
-			what_len = wsgi_req->host_len + 1 + wsgi_req->script_name_len;
+			wsgi_req->appid = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|",1, wsgi_req->script_name, wsgi_req->script_name_len);
+			wsgi_req->appid_len = wsgi_req->host_len + 1 + wsgi_req->script_name_len;
 #ifdef UWSGI_DEBUG
-			uwsgi_debug("VirtualHost SCRIPT_NAME=%s\n", what);
+			uwsgi_debug("VirtualHost KEY=%.*s\n", wsgi_req->appid_len, wsgi_req->appid);
 #endif
+			free_appid = 1;
 		}
-		else {
-			what = wsgi_req->script_name;
-			what_len = wsgi_req->script_name_len;
-		}
+	}
 
 
-		if ( (wsgi_req->app_id = uwsgi_get_app_id(what, what_len, 0))  == -1) {
-			if (wsgi_req->script_name_len > 1 || uwsgi.default_app < 0 || uwsgi.vhost) {
-				/* unavailable app for this SCRIPT_NAME */
-				wsgi_req->app_id = -1;
-				if (wsgi_req->script_len > 0
-						|| wsgi_req->module_len > 0
-						|| wsgi_req->file_len > 0
-						|| wsgi_req->paste_len > 0
-				   ) {
-					// 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);
-					}
-					UWSGI_RELEASE_GIL
-					if (uwsgi.threads > 1) {
-						pthread_mutex_unlock(&up.lock_pyloaders);
-					}
-				}
+	if ( (wsgi_req->app_id = uwsgi_get_app_id(wsgi_req->appid, wsgi_req->appid_len, 0))  == -1) {
+		wsgi_req->app_id = uwsgi.default_app;
+		if (uwsgi.no_default_app) {
+                	wsgi_req->app_id = -1;
+        	}
+		if (wsgi_req->dynamic) {
+			// 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, PYTHON_APP_TYPE_WSGI);
+			}
+			else {
+				wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
+			}
+			UWSGI_RELEASE_GIL
+			if (uwsgi.threads > 1) {
+				pthread_mutex_unlock(&up.lock_pyloaders);
 			}
 		}
-
-		if (uwsgi.vhost) {
-			free(what);
-		}
-
-	}
-	else {
-		wsgi_req->app_id = 0;
 	}
 
+	if (free_appid) {
+		free(wsgi_req->appid);
+	}
 
 	if (wsgi_req->app_id == -1) {
-		// use default app ?
-		if (!uwsgi.no_default_app && uwsgi.default_app >= 0) {
-			wsgi_req->app_id = uwsgi.default_app;
-		}
-		else {
-			internal_server_error(wsgi_req, "wsgi application not found");
-			goto clear2;
-		}
-
+		internal_server_error(wsgi_req, "Python application not found");
+		goto clear2;
 	}
 
-	wi = &uwsgi.apps[wsgi_req->app_id];
+	wi = &uwsgi_apps[wsgi_req->app_id];
 
 	up.swap_ts(wsgi_req, wi);
 	
@@ -437,21 +428,6 @@ 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, "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, "invalid HTTP protocol !!!");
-		goto clear;
-	}
-
-
-
 #ifdef UWSGI_ASYNC
 	wsgi_req->async_environ = wi->environ[wsgi_req->async_id];
 	wsgi_req->async_args = wi->args[wsgi_req->async_id];
@@ -467,60 +443,6 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 	Py_INCREF((PyObject *)wsgi_req->async_environ);
 
-	for (i = 0; i < wsgi_req->var_cnt; i += 2) {
-#ifdef UWSGI_DEBUG
-		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, 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);
-#endif
-		PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
-		Py_DECREF(pydictkey);
-		Py_DECREF(pydictvalue);
-	}
-
-	if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
-		wsgi_req->uh.modifier1 = 0;
-		pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
-		if (pydictkey) {
-			if (PyString_Check(pydictkey)) {
-				pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
-				if (pydictvalue) {
-					if (PyString_Check(pydictvalue)) {
-						path_info = PyString_AsString(pydictvalue);
-						PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
-					}
-				}
-			}
-		}
-	}
-
-
-
-	// 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 {
-		// 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;
-
-	}
-
-	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
-
 	wsgi_req->async_result = wi->request_subhandler(wsgi_req, wi);
 
 	UWSGI_RELEASE_GIL

plugins/python/wsgi_headers.c

@@ -13,7 +13,6 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 	PyObject *headers, *head;
 	PyObject *h_key, *h_value;
 	int i, j;
-	struct uwsgi_header uh;
 	PyObject *exc_info = NULL;
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -39,7 +38,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 			// in this way, error will be reported to the log
 			PyErr_Restore(exc_type, exc_val, exc_tb);
 
-			goto clear;	
+			// the error is reported, let's continue...
+			//goto clear;	
 		}
 	}
 
@@ -70,10 +70,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		}
 
 		wsgi_req->hvec[0].iov_len = wsgi_req->protocol_len;
-		uh.pktsize = wsgi_req->hvec[0].iov_len;
 		wsgi_req->hvec[1].iov_base = " ";
 		wsgi_req->hvec[1].iov_len = 1;
-		uh.pktsize += wsgi_req->hvec[1].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[2].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(head));
 		wsgi_req->hvec[2].iov_len = strlen(wsgi_req->hvec[2].iov_base);
@@ -81,18 +79,15 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[2].iov_base = PyString_AsString(head);
 		wsgi_req->hvec[2].iov_len = PyString_Size(head);
 #endif
-		uh.pktsize += wsgi_req->hvec[2].iov_len;
 		wsgi_req->status = uwsgi_str3_num(wsgi_req->hvec[2].iov_base);
 		wsgi_req->hvec[3].iov_base = nl;
 		wsgi_req->hvec[3].iov_len = NL_SIZE;
-		uh.pktsize += wsgi_req->hvec[3].iov_len;
 	}
 	else {
 		// drop http status on cgi mode
 		base = 3;
 		wsgi_req->hvec[0].iov_base = "Status: ";
 		wsgi_req->hvec[0].iov_len = 8;
-		uh.pktsize = wsgi_req->hvec[0].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[1].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(head));
 		wsgi_req->hvec[1].iov_len = strlen(wsgi_req->hvec[1].iov_base);
@@ -100,11 +95,9 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[1].iov_base = PyString_AsString(head);
 		wsgi_req->hvec[1].iov_len = PyString_Size(head);
 #endif
-		uh.pktsize += wsgi_req->hvec[1].iov_len;
 		wsgi_req->status = uwsgi_str3_num(wsgi_req->hvec[1].iov_base);
 		wsgi_req->hvec[2].iov_base = nl;
 		wsgi_req->hvec[2].iov_len = NL_SIZE;
-		uh.pktsize += wsgi_req->hvec[2].iov_len;
 	}
 
 	headers = PyTuple_GetItem(args, 1);
@@ -146,10 +139,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 		wsgi_req->hvec[j].iov_base = PyString_AsString(h_key);
 		wsgi_req->hvec[j].iov_len = PyString_Size(h_key);
 #endif
-		uh.pktsize += wsgi_req->hvec[j].iov_len;
 		wsgi_req->hvec[j + 1].iov_base = h_sep;
 		wsgi_req->hvec[j + 1].iov_len = H_SEP_SIZE;
-		uh.pktsize += wsgi_req->hvec[j+1].iov_len;
 #ifdef PYTHREE
 		wsgi_req->hvec[j + 2].iov_base = PyBytes_AsString(PyUnicode_AsASCIIString(h_value));
 		wsgi_req->hvec[j + 2].iov_len = strlen(wsgi_req->hvec[j + 2].iov_base);
@@ -158,29 +149,57 @@ 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
+		wsgi_req->headers_size += iov_ret;
+		iov_ptr += iov_size;
+		remains -= iov_size;
+	}
+#else
 	UWSGI_RELEASE_GIL
 		wsgi_req->headers_size = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, j + 1);
 	UWSGI_GET_GIL
-		if (wsgi_req->headers_size < 0) {
-			uwsgi_error("writev()");
-		}
+#endif
 
 	//uwsgi_log("%d %p\n", wsgi_req->poll.fd, up.wsgi_writeout);
 	Py_INCREF(up.wsgi_writeout);

plugins/python/wsgi_subhandler.c

@@ -2,19 +2,74 @@
 
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
 
 void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
 
 	PyObject *zero;
+	int i;
+	PyObject *pydictkey, *pydictvalue;
+	char *path_info;
 
-	//static PyObject *uwsgi_version = NULL;
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                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, 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);
+#endif
 
-	/*
-	   if (uwsgi_version == NULL) {
-	   uwsgi_version = PyString_FromString(UWSGI_VERSION);
-	   }
-	   */
+#ifdef UWSGI_DEBUG
+		uwsgi_log("%p %d %p %d\n", pydictkey, wsgi_req->hvec[i].iov_len, pydictvalue, wsgi_req->hvec[i + 1].iov_len);
+#endif
+                PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
+                Py_DECREF(pydictkey);
+                Py_DECREF(pydictvalue);
+        }
 
+        if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
+                wsgi_req->uh.modifier1 = 0;
+                pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
+                if (pydictkey) {
+                        if (PyString_Check(pydictkey)) {
+                                pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
+                                if (pydictvalue) {
+                                        if (PyString_Check(pydictvalue)) {
+                                                path_info = PyString_AsString(pydictvalue);
+                                                PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
+                                        }
+                                }
+                        }
+                }
+        }
+
+
+#ifndef UWSGI_PYPY
+        // 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 {
+                // 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;
+
+        }
+
+
+        PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
+#endif
 
 #ifdef UWSGI_SENDFILE
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.file_wrapper", wi->sendfile);
@@ -28,19 +83,18 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 #endif
 
-	// cache this
-	zero = PyTuple_New(2);
-	PyTuple_SetItem(zero, 0, PyInt_FromLong(1));
-	PyTuple_SetItem(zero, 1, PyInt_FromLong(0));
-	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.version", zero);
-	Py_DECREF(zero);
+	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.version", wi->gateway_version);
 
-	zero = PyFile_FromFile(stderr, "wsgi_input", "w", NULL);
+#ifndef UWSGI_PYPY
+	zero = PyFile_FromFile(stderr, "wsgi_errors", "w", NULL);
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.errors", zero);
 	Py_DECREF(zero);
+#endif
 
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.run_once", Py_False);
 
+
+
 	if (uwsgi.threads > 1) {
 		PyDict_SetItemString(wsgi_req->async_environ, "wsgi.multithread", Py_True);
 	}
@@ -55,18 +109,18 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 
 	if (wsgi_req->scheme_len > 0) {
-		zero = PyString_FromStringAndSize(wsgi_req->scheme, wsgi_req->scheme_len);
+		zero = UWSGI_PYFROMSTRINGSIZE(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') {
-			zero = PyString_FromString("https");
+			zero = UWSGI_PYFROMSTRING("https");
 		}
 		else {
-			zero = PyString_FromString("http");
+			zero = UWSGI_PYFROMSTRING("http");
 		}
 	}
 	else {
-		zero = PyString_FromString("http");
+		zero = UWSGI_PYFROMSTRING("http");
 	}
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.url_scheme", zero);
 	Py_DECREF(zero);
@@ -74,19 +128,23 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
 	wsgi_req->async_app = wi->callable;
 
+
 	// export .env only in non-threaded mode
+#ifndef UWSGI_PYPY
 	if (uwsgi.threads < 2) {
 		PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
 	}
+#endif
 
-	zero = PyString_FromString(UWSGI_VERSION);
-	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", zero);
-	Py_DECREF(zero);
+	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
 
 	if (uwsgi.cores > 1) {
-		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+		zero = PyInt_FromLong(wsgi_req->async_id);
+		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", zero);
+		Py_DECREF(zero);
 	}
 
+	// cache this ?
 	if (uwsgi.cluster_fd >= 0) {
 		zero = PyString_FromString(uwsgi.cluster);
 		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
@@ -96,6 +154,8 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 		Py_DECREF(zero);
 	}
 
+	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
+
 
 #ifdef UWSGI_ROUTING
 	uwsgi_log("routing %d routes %d\n", uwsgi.routing, uwsgi.nroutes);
@@ -109,7 +169,7 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
 
 	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
-	return python_call(wsgi_req->async_app, wsgi_req->async_args, up.catch_exceptions);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, up.catch_exceptions, wsgi_req);
 }
 
 int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
@@ -134,7 +194,11 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 
 
 #ifdef UWSGI_SENDFILE
+#ifdef __FreeBSD__
+	if ( ((wsgi_req->sendfile_obj == wsgi_req->async_result) || ( wsgi_req->sendfile_fd_size > 0 && wsgi_req->response_size < wsgi_req->sendfile_fd_size)) && wsgi_req->sendfile_fd != -1) {
+#else
 	if (wsgi_req->sendfile_obj == wsgi_req->async_result && wsgi_req->sendfile_fd != -1) {
+#endif
 		sf_len = uwsgi_sendfile(wsgi_req);
 		if (sf_len < 1) goto clear;
 		wsgi_req->response_size += sf_len;
@@ -176,6 +240,7 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 				uwsgi_log("Memory Error detected !!!\n");	
 			}		
 			uwsgi.workers[uwsgi.mywid].exceptions++;
+			uwsgi_apps[wsgi_req->app_id].exceptions++;
 			PyErr_Print();
 		}	
 		goto clear;

plugins/python24/uwsgiplugin.py

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

plugins/python25/uwsgiplugin.py

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

plugins/python26/uwsgiplugin.py

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

plugins/python27/uwsgiplugin.py

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