uWSGI 1.9.4

refactored legion opt functions to be more plugin friendly

apache2/mod_proxy_uwsgi.c

@@ -217,6 +217,45 @@ static int uwsgi_send_body(request_rec *r, proxy_conn_rec *conn)
     return OK;
 }
 
+#if AP_MODULE_MAGIC_AT_LEAST(20111130,0)
+static request_rec *ap_proxy_make_fake_req(conn_rec *c, request_rec *r)
+{
+    apr_pool_t *pool;
+    request_rec *rp;
+
+    apr_pool_create(&pool, c->pool);
+
+    rp = apr_pcalloc(pool, sizeof(*r));
+
+    rp->pool            = pool;
+    rp->status          = HTTP_OK;
+
+    rp->headers_in      = apr_table_make(pool, 50);
+    rp->subprocess_env  = apr_table_make(pool, 50);
+    rp->headers_out     = apr_table_make(pool, 12);
+    rp->err_headers_out = apr_table_make(pool, 5);
+    rp->notes           = apr_table_make(pool, 5);
+
+    rp->server = r->server;
+    rp->log = r->log;
+    rp->proxyreq = r->proxyreq;
+    rp->request_time = r->request_time;
+    rp->connection      = c;
+    rp->output_filters  = c->output_filters;
+    rp->input_filters   = c->input_filters;
+    rp->proto_output_filters  = c->output_filters;
+    rp->proto_input_filters   = c->input_filters;
+    rp->useragent_ip = c->client_ip;
+    rp->useragent_addr = c->client_addr;
+
+    rp->request_config  = ap_create_request_config(pool);
+    proxy_run_create_req(r, rp);
+
+    return rp;
+}
+#endif
+
+
 static int uwsgi_response(request_rec *r, proxy_conn_rec *backend, proxy_server_conf *conf)
 {
 
@@ -337,7 +376,11 @@ static int uwsgi_handler(request_rec *r, proxy_worker *worker,
     }
 
     // ADD PATH_INFO
+#if AP_MODULE_MAGIC_AT_LEAST(20111130,0)
+    size_t w_len = strlen(worker->s->name);
+#else
     size_t w_len = strlen(worker->name);
+#endif
     char *u_path_info = r->filename + 6 + w_len;
     int delta = 0;
     if (u_path_info[0] != '/') {

core/cache.c

@@ -533,7 +533,8 @@ void uwsgi_cache_fix(struct uwsgi_cache *uc) {
 		}
 	}
 
-	uwsgi_log("[uwsgi-cache] restored %llu items\n", restored);
+	uc->n_items = restored;
+	uwsgi_log("[uwsgi-cache] restored %llu items\n", uc->n_items);
 }
 
 int uwsgi_cache_set2(struct uwsgi_cache *uc, char *key, uint16_t keylen, char *val, uint64_t vallen, uint64_t expires, uint64_t flags) {

core/config.c

@@ -0,0 +1,33 @@
+#include <uwsgi.h>
+
+/*
+
+	pluggable configuration system
+
+*/
+
+extern struct uwsgi_server uwsgi;
+
+struct uwsgi_configurator *uwsgi_register_configurator(char *name, void (*func)(char *, char **)) {
+	struct uwsgi_configurator *old_uc = NULL,*uc = uwsgi.configurators;
+        while(uc) {
+                if (!strcmp(uc->name, name)) {
+                        return uc;
+                }
+                old_uc = uc;
+                uc = uc->next;
+        }
+
+        uc = uwsgi_calloc(sizeof(struct uwsgi_configurator));
+        uc->name = name;
+        uc->func = func;
+
+        if (old_uc) {
+                old_uc->next = uc;
+        }
+        else {
+                uwsgi.configurators = uc;
+        }
+
+        return uc;
+}

core/emperor.c

@@ -122,16 +122,27 @@ void uwsgi_emperor_blacklist_remove(char *id) {
 
 struct uwsgi_emperor_scanner *emperor_scanners;
 
+static int has_extra_extension(char *name) {
+	struct uwsgi_string_list *usl = uwsgi.emperor_extra_extension;
+	while(usl) {
+		if (uwsgi_endswith(name, usl->value)) {
+			return 1;
+		}
+		usl = usl->next;	
+	}
+	return 0;
+}
+
 int uwsgi_emperor_is_valid(char *name) {
 
-	if (uwsgi_endswith(name, ".xml") || uwsgi_endswith(name, ".ini") || uwsgi_endswith(name, ".yml") || uwsgi_endswith(name, ".yaml") || uwsgi_endswith(name, ".js") || uwsgi_endswith(name, ".json")) {
-
+	if (uwsgi_endswith(name, ".xml") || uwsgi_endswith(name, ".ini") || uwsgi_endswith(name, ".yml") || uwsgi_endswith(name, ".yaml") || uwsgi_endswith(name, ".js") || uwsgi_endswith(name, ".json") || has_extra_extension(name)) {
 
 		if (strlen(name) < 0xff) {
 			return 1;
 		}
 	}
 
+
 	return 0;
 }
 
@@ -231,10 +242,27 @@ void uwsgi_imperial_monitor_directory(struct uwsgi_emperor_scanner *ues) {
 
 		ui_current = emperor_get(de->d_name);
 
+		uid_t t_uid = st.st_uid;
+		gid_t t_gid = st.st_gid;
+
+		if (uwsgi.emperor_tyrant && uwsgi.emperor_tyrant_nofollow) {
+			struct stat lst;
+			if (lstat(de->d_name, &lst)) {
+				uwsgi_error("[emperor-tyrant]/lstat()");
+				if (ui_current) {
+					uwsgi_log("!!! availability of file %s changed. stopping the instance... !!!\n", de->d_name);
+					emperor_stop(ui_current);
+				}
+				continue;
+			}
+			t_uid = lst.st_uid;
+			t_gid = lst.st_gid;
+		}
+
 		if (ui_current) {
 			// check if uid or gid are changed, in such case, stop the instance
 			if (uwsgi.emperor_tyrant) {
-				if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+				if (t_uid != ui_current->uid || t_gid != ui_current->gid) {
 					uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n", de->d_name);
 					emperor_stop(ui_current);
 					continue;
@@ -247,7 +275,7 @@ void uwsgi_imperial_monitor_directory(struct uwsgi_emperor_scanner *ues) {
 		}
 		else {
 			char *socket_name = emperor_check_on_demand_socket(de->d_name);
-			emperor_add(ues, de->d_name, st.st_mtime, NULL, 0, st.st_uid, st.st_gid, socket_name);
+			emperor_add(ues, de->d_name, st.st_mtime, NULL, 0, t_uid, t_gid, socket_name);
 			if (socket_name) free(socket_name);
 		}
 	}
@@ -308,10 +336,27 @@ void uwsgi_imperial_monitor_glob(struct uwsgi_emperor_scanner *ues) {
 
 		ui_current = emperor_get(g.gl_pathv[i]);
 
+		uid_t t_uid = st.st_uid;
+                gid_t t_gid = st.st_gid;
+
+                if (uwsgi.emperor_tyrant && uwsgi.emperor_tyrant_nofollow) {
+                        struct stat lst;
+                        if (lstat(g.gl_pathv[i], &lst)) {
+                                uwsgi_error("[emperor-tyrant]/lstat()");
+                                if (ui_current) {
+                                        uwsgi_log("!!! availability of file %s changed. stopping the instance... !!!\n", g.gl_pathv[i]);
+                                        emperor_stop(ui_current);
+                                }
+                                continue;
+                        }
+                        t_uid = lst.st_uid;
+                        t_gid = lst.st_gid;
+                }
+
 		if (ui_current) {
 			// check if uid or gid are changed, in such case, stop the instance
 			if (uwsgi.emperor_tyrant) {
-				if (st.st_uid != ui_current->uid || st.st_gid != ui_current->gid) {
+				if (t_uid != ui_current->uid || t_gid != ui_current->gid) {
 					uwsgi_log("!!! permissions of file %s changed. stopping the instance... !!!\n", g.gl_pathv[i]);
 					emperor_stop(ui_current);
 					continue;
@@ -324,7 +369,7 @@ void uwsgi_imperial_monitor_glob(struct uwsgi_emperor_scanner *ues) {
 		}
 		else {
 			char *socket_name = emperor_check_on_demand_socket(g.gl_pathv[i]);
-			emperor_add(ues, g.gl_pathv[i], st.st_mtime, NULL, 0, st.st_uid, st.st_gid, socket_name);
+			emperor_add(ues, g.gl_pathv[i], st.st_mtime, NULL, 0, t_uid, t_gid, socket_name);
 			if (socket_name) free(socket_name);
 		}
 
@@ -882,6 +927,15 @@ int uwsgi_emperor_vassal_start(struct uwsgi_instance *n_ui) {
 			vassal_argv[1] = "--json";
 		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 5), ".json"))
 			vassal_argv[1] = "--json";
+	
+		struct uwsgi_string_list *usl = uwsgi.emperor_extra_extension;
+		while(usl) {
+			if (uwsgi_endswith(n_ui->name, usl->value)) {
+				vassal_argv[1] = "--config";
+				break;
+			}
+			usl = usl->next;
+		}
 
 		if (colon) {
 			colon[0] = ':';

core/event.c

@@ -260,7 +260,7 @@ int event_queue_del_fd(int eq, int fd, int event) {
 
 int event_queue_fd_write_to_read(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -271,7 +271,7 @@ int event_queue_fd_write_to_read(int eq, int fd) {
 
 int event_queue_fd_read_to_write(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -282,7 +282,7 @@ int event_queue_fd_read_to_write(int eq, int fd) {
 
 int event_queue_fd_readwrite_to_read(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -293,7 +293,7 @@ int event_queue_fd_readwrite_to_read(int eq, int fd) {
 
 int event_queue_fd_readwrite_to_write(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -304,7 +304,7 @@ int event_queue_fd_readwrite_to_write(int eq, int fd) {
 
 int event_queue_fd_write_to_readwrite(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN | POLLOUT, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN | POLLOUT, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -315,7 +315,7 @@ int event_queue_fd_write_to_readwrite(int eq, int fd) {
 
 int event_queue_fd_read_to_readwrite(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN | POLLOUT, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN | POLLOUT, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -351,7 +351,7 @@ int event_queue_interesting_fd_is_write(void *events, int id) {
 
 int event_queue_add_fd_read(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLIN, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -361,7 +361,7 @@ int event_queue_add_fd_read(int eq, int fd) {
 
 int event_queue_add_fd_write(int eq, int fd) {
 
-	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, NULL)) {
+	if (port_associate(eq, PORT_SOURCE_FD, fd, POLLOUT, (void *)((long) eq))) {
 		uwsgi_error("port_associate");
 		return -1;
 	}
@@ -381,7 +381,7 @@ int event_queue_interesting_fd(void *events, int id) {
 	}
 
 	int fd = (int) pe[id].portev_object;
-	int eq = (int) pe[id].portev_user;
+	int eq = (long) pe[id].portev_user;
 
 	if (pe[id].portev_events == POLLOUT) {
 		event_queue_add_fd_write(eq, fd);
@@ -423,7 +423,7 @@ int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
 		port_event_t *pe_i = &pe[i];
 		if (pe_i->portev_source == PORT_SOURCE_FD) {
                 	// event must be readded (damn Oracle/Sun why the fu*k you made such a horrible choice ???? why not adding a ONESHOT flag ???)
-                	if (port_associate(eq, pe_i->portev_source, pe_i->portev_object, pe_i->portev_events, NULL)) {
+                	if (port_associate(eq, pe_i->portev_source, pe_i->portev_object, pe_i->portev_events, (void *)((long) eq))) {
                         	uwsgi_error("port_associate");
                 	}
         	}
@@ -449,16 +449,16 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 		ret = port_get(eq, &pe, NULL);
 	}
 	if (ret < 0) {
-		if (errno != ETIME) {
+		if (errno == ETIME) return 0;
+		if (errno != EINTR) {
 			uwsgi_error("port_get()");
-			return -1;
 		}
-		return 0;
+		return -1;
 	}
 
 	if (pe.portev_source == PORT_SOURCE_FD) {
 		// event must be readded (damn Oracle/Sun why the fu*k you made such a horrible choice ???? why not adding a ONESHOT flag ???)
-		if (port_associate(eq, pe.portev_source, pe.portev_object, pe.portev_events, NULL)) {
+		if (port_associate(eq, pe.portev_source, pe.portev_object, pe.portev_events, (void *)((long) eq))) {
 			uwsgi_error("port_associate");
 		}
 	}

core/legion.c

@@ -203,7 +203,6 @@ static void legions_check_nodes() {
 
 		struct uwsgi_legion_node *node = legion->nodes_head;
 		while (node) {
-
 			if (now - node->last_seen > uwsgi.legion_tolerance) {
 				struct uwsgi_legion_node *tmp_node = node;
 				node = node->next;
@@ -302,6 +301,18 @@ static void legions_check_nodes_step2() {
 
 		// we have quorum !!!
 		if (votes > 0 && votes >= ul->quorum) {
+			if (!ul->joined) {
+				// triggering join hooks
+				struct uwsgi_string_list *usl = ul->join_hooks;
+				while (usl) {
+					int ret = uwsgi_legion_action_call("join", ul, usl);
+					if (ret) {
+						uwsgi_log("[uwsgi-legion] ERROR, join hook returned: %d\n", ret);
+					}
+					usl = usl->next;
+				}
+				ul->joined = 1;
+			}
 			// something changed ???
 			if (ul->changed) {
 				legions_report_quorum(ul, best_valor, best_uuid, votes);
@@ -763,15 +774,20 @@ void uwsgi_opt_legion_node(char *opt, char *value, void *foobar) {
 		exit(1);
 	}
 
-	struct uwsgi_string_list *usl = uwsgi_string_new_list(&ul->nodes, space + 1);
-	char *port = strchr(usl->value, ':');
+	uwsgi_legion_register_node(ul, space + 1);
+	
+}
+
+void uwsgi_legion_register_node(struct uwsgi_legion *ul, char *addr) {
+	struct uwsgi_string_list *usl = uwsgi_string_new_list(&ul->nodes, addr);
+	char *port = strchr(addr, ':');
 	if (!port) {
-		uwsgi_log("[uwsgi-legion] invalid udp address: %s\n", usl->value);
+		uwsgi_log("[uwsgi-legion] invalid udp address: %s\n", addr);
 		exit(1);
 	}
 	// no need to zero the memory, socket_to_in_addr will do that
 	struct sockaddr_in *sin = uwsgi_malloc(sizeof(struct sockaddr_in));
-	usl->custom = socket_to_in_addr(usl->value, port, 0, sin);
+	usl->custom = socket_to_in_addr(addr, port, 0, sin);
 	usl->custom_ptr = sin;
 }
 
@@ -823,51 +839,69 @@ void uwsgi_opt_legion_scroll(char *opt, char *value, void *foobar) {
 
 void uwsgi_opt_legion_hook(char *opt, char *value, void *foobar) {
 
+	char *event = strchr(opt, '-');
+	if (!event) {
+		uwsgi_log("[uwsgi-legion] invalid option name (%s), this should not happen (possible bug)\n", opt);
+		exit(1);
+	}
+  
 	char *legion = uwsgi_str(value);
-
+	
 	char *space = strchr(legion, ' ');
 	if (!space) {
-		uwsgi_log("invalid %s syntax, must be <legion> <action>\n", opt);
+		uwsgi_log("[uwsgi-legion] invalid %s syntax, must be <legion> <action>\n", opt);
 		exit(1);
 	}
 	*space = 0;
 
 	struct uwsgi_legion *ul = uwsgi_legion_get_by_name(legion);
 	if (!ul) {
-		uwsgi_log("unknown legion: %s\n", legion);
+		uwsgi_log("[uwsgi-legion] unknown legion: %s\n", legion);
 		exit(1);
 	}
 
+	uwsgi_legion_register_hook(ul, event + 1, space + 1);
+}
+
+void uwsgi_legion_register_hook(struct uwsgi_legion *ul, char *event, char *action) {
+
 	struct uwsgi_string_list *usl = NULL;
 
-	if (!strcmp(opt, "legion-lord")) {
-		usl = uwsgi_string_new_list(&ul->lord_hooks, space + 1);
+	if (!strcmp(event, "lord")) {
+		usl = uwsgi_string_new_list(&ul->lord_hooks, action);
 	}
-	else if (!strcmp(opt, "legion-unlord")) {
-		usl = uwsgi_string_new_list(&ul->unlord_hooks, space + 1);
+	else if (!strcmp(event, "unlord")) {
+		usl = uwsgi_string_new_list(&ul->unlord_hooks, action);
 	}
-	else if (!strcmp(opt, "legion-setup")) {
-		usl = uwsgi_string_new_list(&ul->setup_hooks, space + 1);
+	else if (!strcmp(event, "setup")) {
+		usl = uwsgi_string_new_list(&ul->setup_hooks, action);
 	}
-	else if (!strcmp(opt, "legion-death")) {
-		usl = uwsgi_string_new_list(&ul->death_hooks, space + 1);
+	else if (!strcmp(event, "death")) {
+		usl = uwsgi_string_new_list(&ul->death_hooks, action);
+	}
+	else if (!strcmp(event, "join")) {
+		usl = uwsgi_string_new_list(&ul->join_hooks, action);
+	}
+	else {
+		uwsgi_log("[uwsgi-legion] invalid event: %s\n", event);
+		exit(1);
 	}
 
 	if (!usl)
 		return;
 
-	char *port = strchr(usl->value, ':');
-	if (!port) {
-		uwsgi_log("[uwsgi-legion] invalid %s action: %s\n", opt, usl->value);
+	char *hook = strchr(action, ':');
+	if (!hook) {
+		uwsgi_log("[uwsgi-legion] invalid %s action: %s\n", event, action);
 		exit(1);
 	}
 
 	// pointer to action plugin
-	usl->custom_ptr = uwsgi_concat2n(usl->value, port - usl->value, "", 0);
+	usl->custom_ptr = uwsgi_concat2n(action, hook - action, "", 0);;
 	// add that to check the plugin value
-	usl->custom = port - usl->value + 1;
-}
+	usl->custom = hook - action + 1;
 
+}
 
 void uwsgi_opt_legion(char *opt, char *value, void *foobar) {
 
@@ -905,6 +939,10 @@ void uwsgi_opt_legion(char *opt, char *value, void *foobar) {
 	*colon = 0;
 	char *secret = colon + 1;
 
+	uwsgi_legion_register(legion, addr, valor, algo_secret, secret);
+}
+
+struct uwsgi_legion *uwsgi_legion_register(char *legion, char *addr, char *valor, char *algo, char *secret) {
 	char *iv = strchr(secret, ' ');
 	if (iv) {
 		*iv = 0;
@@ -918,9 +956,9 @@ void uwsgi_opt_legion(char *opt, char *value, void *foobar) {
 	EVP_CIPHER_CTX *ctx = uwsgi_malloc(sizeof(EVP_CIPHER_CTX));
 	EVP_CIPHER_CTX_init(ctx);
 
-	const EVP_CIPHER *cipher = EVP_get_cipherbyname(algo_secret);
+	const EVP_CIPHER *cipher = EVP_get_cipherbyname(algo);
 	if (!cipher) {
-		uwsgi_log("[uwsgi-legion] unable to find algorithm/cipher %s\n", algo_secret);
+		uwsgi_log("[uwsgi-legion] unable to find algorithm/cipher %s\n", algo);
 		exit(1);
 	}
 
@@ -983,6 +1021,8 @@ void uwsgi_opt_legion(char *opt, char *value, void *foobar) {
 	ul->scrolls = uwsgi_calloc_shared(ul->scrolls_max_size);
 
 	uwsgi_legion_add(ul);
+
+	return ul;
 }
 
 struct uwsgi_legion_action *uwsgi_legion_action_get(char *name) {

core/master.c

@@ -798,8 +798,8 @@ int master_loop(char **argv, char **environ) {
 
 		 */
 
-		uwsgi.mywid = find_worker_id(diedpid);
-		if (uwsgi.mywid <= 0) {
+		int thewid = find_worker_id(diedpid);
+		if (thewid <= 0) {
 			// check spooler, mules, gateways and daemons
 			struct uwsgi_spooler *uspool = uwsgi.spoolers;
 			while (uspool) {
@@ -842,50 +842,50 @@ next:
 
 
 		// ok a worker died...
-		uwsgi.workers[uwsgi.mywid].pid = 0;
+		uwsgi.workers[thewid].pid = 0;
 		// only to be safe :P
-		uwsgi.workers[uwsgi.mywid].harakiri = 0;
+		uwsgi.workers[thewid].harakiri = 0;
 
 		// ok, if we are reloading or dying, just continue the master loop
 		// as soon as all of the workers have pid == 0, the action (exit, or reload) is triggered
 		if (uwsgi_instance_is_reloading || uwsgi_instance_is_dying) {
-			uwsgi_log("worker %d buried after %d seconds\n", uwsgi.mywid, (int) (uwsgi_now()-uwsgi.workers[uwsgi.mywid].cursed_at));
-			uwsgi.workers[uwsgi.mywid].cursed_at = 0;
+			uwsgi_log("worker %d buried after %d seconds\n", thewid, (int) (uwsgi_now()-uwsgi.workers[thewid].cursed_at));
+			uwsgi.workers[thewid].cursed_at = 0;
 			continue;
 		}
 
 		// if we are stopping workers, just end here
 
 		if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_FAILED_APP_CODE) {
-			uwsgi_log("OOPS ! failed loading app in worker %d (pid %d) :( trying again...\n", uwsgi.mywid, (int) diedpid);
+			uwsgi_log("OOPS ! failed loading app in worker %d (pid %d) :( trying again...\n", thewid, (int) diedpid);
 		}
 		else if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_DE_HIJACKED_CODE) {
-			uwsgi_log("...restoring worker %d (pid: %d)...\n", uwsgi.mywid, (int) diedpid);
+			uwsgi_log("...restoring worker %d (pid: %d)...\n", thewid, (int) diedpid);
 		}
 		else if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_EXCEPTION_CODE) {
-			uwsgi_log("... monitored exception detected, respawning worker %d (pid: %d)...\n", uwsgi.mywid, (int) diedpid);
+			uwsgi_log("... monitored exception detected, respawning worker %d (pid: %d)...\n", thewid, (int) diedpid);
 		}
 		else if (WIFEXITED(waitpid_status) && WEXITSTATUS(waitpid_status) == UWSGI_QUIET_CODE) {
 			// noop
 		}
-		else if (uwsgi.workers[uwsgi.mywid].manage_next_request) {
+		else if (uwsgi.workers[thewid].manage_next_request) {
 			if (WIFSIGNALED(waitpid_status)) {
-				uwsgi_log("DAMN ! worker %d (pid: %d) died, killed by signal %d :( trying respawn ...\n", uwsgi.mywid, (int) diedpid, (int) WTERMSIG(waitpid_status));
+				uwsgi_log("DAMN ! worker %d (pid: %d) died, killed by signal %d :( trying respawn ...\n", thewid, (int) diedpid, (int) WTERMSIG(waitpid_status));
 			}
 			else {
-				uwsgi_log("DAMN ! worker %d (pid: %d) died :( trying respawn ...\n", uwsgi.mywid, (int) diedpid);
+				uwsgi_log("DAMN ! worker %d (pid: %d) died :( trying respawn ...\n", thewid, (int) diedpid);
 			}
 		}
-		else if (uwsgi.workers[uwsgi.mywid].cursed_at > 0) {
-			uwsgi_log("worker %d killed successfully (pid: %d)\n", uwsgi.mywid, (int) diedpid);
+		else if (uwsgi.workers[thewid].cursed_at > 0) {
+			uwsgi_log("worker %d killed successfully (pid: %d)\n", thewid, (int) diedpid);
 		}
 		// manage_next_request is zero, but killed by signal...
 		else if (WIFSIGNALED(waitpid_status)) {
-			uwsgi_log("DAMN ! worker %d (pid: %d) MISTERIOUSLY killed by signal %d :( trying respawn ...\n", uwsgi.mywid, (int) diedpid, (int) WTERMSIG(waitpid_status));
+			uwsgi_log("DAMN ! worker %d (pid: %d) MISTERIOUSLY killed by signal %d :( trying respawn ...\n", thewid, (int) diedpid, (int) WTERMSIG(waitpid_status));
 		}
 
-		if (uwsgi.workers[uwsgi.mywid].cheaped == 1) {
-			uwsgi_log("uWSGI worker %d cheaped.\n", uwsgi.mywid);
+		if (uwsgi.workers[thewid].cheaped == 1) {
+			uwsgi_log("uWSGI worker %d cheaped.\n", thewid);
 			continue;
 		}
 
@@ -909,12 +909,12 @@ next:
 		uwsgi.respawn_delta = last_respawn.tv_sec;
 
 		// are we chain reloading it ?
-		if (uwsgi.status.chain_reloading == uwsgi.mywid) {
+		if (uwsgi.status.chain_reloading == thewid) {
 			uwsgi.status.chain_reloading++;
 		}
 
 		// respawn the worker (if needed)
-		if (uwsgi_respawn_worker(uwsgi.mywid))
+		if (uwsgi_respawn_worker(thewid))
 			return 0;
 
 		// end of the loop

core/master_utils.c

@@ -413,9 +413,6 @@ void uwsgi_reload(char **argv) {
 #endif
 	}
 
-#ifdef UWSGI_AS_SHARED_LIBRARY
-	return;
-#else
 	uwsgi_log("running %s\n", uwsgi.binary_path);
 	uwsgi_flush_logs();
 	argv[0] = uwsgi.binary_path;
@@ -436,7 +433,6 @@ void uwsgi_reload(char **argv) {
 	uwsgi_error("execvp()");
 	// never here
 	exit(1);
-#endif
 
 }
 
@@ -957,6 +953,9 @@ struct uwsgi_stats *uwsgi_master_generate_stats() {
 			uc = uc->next;
 		}
 
+		if (uwsgi_stats_list_close(us))
+		goto end;
+
 		if (uwsgi_stats_comma(us))
 		goto end;
 	}

core/mule.c

@@ -184,6 +184,7 @@ void uwsgi_mule_handler() {
 		if (interesting_fd == uwsgi.signal_socket || interesting_fd == uwsgi.my_signal_socket || farm_has_signaled(interesting_fd)) {
 			len = read(interesting_fd, &uwsgi_signal, 1);
 			if (len <= 0) {
+				if (len < 0 && (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK)) continue;
 				uwsgi_log_verbose("uWSGI mule %d braying: my master died, i will follow him...\n", uwsgi.muleid);
 				end_me(0);
 			}
@@ -197,7 +198,9 @@ void uwsgi_mule_handler() {
 		else if (interesting_fd == uwsgi.mules[uwsgi.muleid - 1].queue_pipe[1] || interesting_fd == uwsgi.shared->mule_queue_pipe[1] || farm_has_msg(interesting_fd)) {
 			len = read(interesting_fd, message, 65536);
 			if (len < 0) {
-				uwsgi_error("read()");
+				if (errno != EAGAIN && errno != EINTR && errno != EWOULDBLOCK) {
+					uwsgi_error("uwsgi_mule_handler/read()");
+				}
 			}
 			else {
 				int i, found = 0;
@@ -343,6 +346,7 @@ next:
 				if (interesting_fd > -1) {
 					len = read(interesting_fd, &uwsgi_signal, 1);
 					if (len <= 0) {
+						if (len < 0 && (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK)) goto clear;
 						uwsgi_log_verbose("uWSGI mule %d braying: my master died, i will follow him...\n", uwsgi.muleid);
 						end_me(0);
 					}
@@ -350,7 +354,7 @@ next:
 					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);
+						uwsgi_log_verbose("error managing signal %d on mule %d\n", uwsgi_signal, uwsgi.muleid);
 					}
 					// set the error condition
 					len = -1;

core/routing.c

@@ -157,6 +157,8 @@ int uwsgi_apply_routes_do(struct wsgi_request *wsgi_req, char *subject, uint16_t
 
 	while (routes) {
 
+		if (routes->label) goto next;
+
 		if (wsgi_req->route_goto > 0 && wsgi_req->route_pc < wsgi_req->route_goto) {
 			goto next;
 		}

core/signal.c

@@ -260,6 +260,8 @@ int uwsgi_add_probe(uint8_t sig, char *kind, char *args, int timeout, int freq)
 
 int uwsgi_add_timer(uint8_t sig, int secs) {
 
+	if (!uwsgi.master_process) return -1;
+
 	uwsgi_lock(uwsgi.timer_table_lock);
 
 	if (ushared->timers_cnt < 64) {
@@ -595,7 +597,7 @@ void uwsgi_receive_signal(int fd, char *name, int id) {
 	if (ret == 0) {
 		goto destroy;
 	}
-	else if (ret < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
+	else if (ret < 0 && errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
 		uwsgi_error("[uwsgi-signal] read()");
 		goto destroy;
 	}

core/spooler.c

@@ -108,7 +108,6 @@ pid_t spooler_start(struct uwsgi_spooler * uspool) {
                 signal(SIGSTOP, SIG_IGN);
                 signal(SIGTSTP, SIG_IGN);
 
-		uwsgi.mywid = -1;
 		uwsgi.mypid = getpid();
 		uspool->pid = uwsgi.mypid;
 		// avoid race conditions !!!

core/uwsgi.c

@@ -70,6 +70,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"xmlconfig", required_argument, 'x', "load config from xml file", uwsgi_opt_load_xml, NULL, UWSGI_OPT_IMMEDIATE},
 	{"xml", required_argument, 'x', "load config from xml file", uwsgi_opt_load_xml, NULL, UWSGI_OPT_IMMEDIATE},
 #endif
+	{"config", required_argument, 0, "load configuration using the pluggable system", uwsgi_opt_load_config, NULL, UWSGI_OPT_IMMEDIATE},
 
 	{"skip-zero", no_argument, 0, "skip check of file descriptor 0", uwsgi_opt_true, &uwsgi.skip_zero, 0},
 
@@ -171,6 +172,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"emperor-required-heartbeat", required_argument, 0, "set the Emperor tolerance about heartbeats", uwsgi_opt_set_int, &uwsgi.emperor_heartbeat, 0},
 	{"emperor-pidfile", required_argument, 0, "write the Emperor pid in the specified file", uwsgi_opt_set_str, &uwsgi.emperor_pidfile, 0},
 	{"emperor-tyrant", no_argument, 0, "put the Emperor in Tyrant mode", uwsgi_opt_true, &uwsgi.emperor_tyrant, 0},
+	{"emperor-tyrant-nofollow", no_argument, 0, "do not follow symlinks when checking for uid/gid in Tyrant mode", uwsgi_opt_true, &uwsgi.emperor_tyrant_nofollow, 0},
 	{"emperor-stats", required_argument, 0, "run the Emperor stats server", uwsgi_opt_set_str, &uwsgi.emperor_stats, 0},
 	{"emperor-stats-server", required_argument, 0, "run the Emperor stats server", uwsgi_opt_set_str, &uwsgi.emperor_stats, 0},
 	{"early-emperor", no_argument, 0, "spawn the emperor as soon as possibile", uwsgi_opt_true, &uwsgi.early_emperor, 0},
@@ -183,6 +185,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"emperor-on-demand-directory", required_argument, 0, "enable on demand mode binding to the unix socket in the specified directory named like the vassal + .socket", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_directory, 0},
 	{"emperor-on-demand-dir", required_argument, 0, "enable on demand mode binding to the unix socket in the specified directory named like the vassal + .socket", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_directory, 0},
 	{"emperor-on-demand-exec", required_argument, 0, "use the output of the specified command as on demand socket name (the vassal name is passed as the only argument)", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_exec, 0},
+	{"emperor-extra-extension", required_argument, 0, "allows the specified extension in the Emperor (vassal will be called with --config)", uwsgi_opt_add_string_list, &uwsgi.emperor_extra_extension, 0},
+	{"emperor-extra-ext", required_argument, 0, "allows the specified extension in the Emperor (vassal will be called with --config)", uwsgi_opt_add_string_list, &uwsgi.emperor_extra_extension, 0},
 	{"imperial-monitor-list", no_argument, 0, "list enabled imperial monitors", uwsgi_opt_true, &uwsgi.imperial_monitor_list, 0},
 	{"imperial-monitors-list", no_argument, 0, "list enabled imperial monitors", uwsgi_opt_true, &uwsgi.imperial_monitor_list, 0},
 	{"vassals-inherit", required_argument, 0, "add config templates to vassals config", uwsgi_opt_add_string_list, &uwsgi.vassals_templates, 0},
@@ -263,6 +267,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"chroot", required_argument, 0, "chroot() to the specified directory", uwsgi_opt_set_str, &uwsgi.chroot, 0},
 	{"uid", required_argument, 0, "setuid to the specified user/uid", uwsgi_opt_set_uid, NULL, 0},
 	{"gid", required_argument, 0, "setgid to the specified group/gid", uwsgi_opt_set_gid, NULL, 0},
+	{"immediate-uid", required_argument, 0, "setuid to the specified user/uid IMMEDIATELY", uwsgi_opt_set_immediate_uid, NULL, UWSGI_OPT_IMMEDIATE},
+	{"immediate-gid", required_argument, 0, "setgid to the specified group/gid IMMEDIATELY", uwsgi_opt_set_immediate_gid, NULL, UWSGI_OPT_IMMEDIATE},
 	{"no-initgroups", no_argument, 0, "disable additional groups set via initgroups()", uwsgi_opt_true, &uwsgi.no_initgroups, 0},
 #ifdef UWSGI_CAP
 	{"cap", required_argument, 0, "set process capability", uwsgi_opt_set_cap, NULL, 0},
@@ -377,6 +383,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"legion-unlord", required_argument, 0, "action to call on Lord dismiss", uwsgi_opt_legion_hook, NULL, UWSGI_OPT_MASTER},
 	{"legion-setup", required_argument, 0, "action to call on legion setup", uwsgi_opt_legion_hook, NULL, UWSGI_OPT_MASTER},
 	{"legion-death", required_argument, 0, "action to call on legion death (shutdown of the instance)", uwsgi_opt_legion_hook, NULL, UWSGI_OPT_MASTER},
+	{"legion-join", required_argument, 0, "action to call on legion join (first time quorum is reached)", uwsgi_opt_legion_hook, NULL, UWSGI_OPT_MASTER},
 	{"legion-quorum", required_argument, 0, "set the quorum of a legion", uwsgi_opt_legion_quorum, NULL, UWSGI_OPT_MASTER},
 	{"legion-scroll", required_argument, 0, "set the scroll of a legion", uwsgi_opt_legion_scroll, NULL, UWSGI_OPT_MASTER},
 	{"legion-scroll-max-size", required_argument, 0, "set max size of legion scroll buffer", uwsgi_opt_set_16bit, &uwsgi.legion_scroll_max_size, 0},
@@ -3185,6 +3192,59 @@ void uwsgi_opt_true(char *opt, char *value, void *key) {
 	}
 }
 
+void uwsgi_opt_set_immediate_gid(char *opt, char *value, void *none) {
+        gid_t gid = atoi(value);
+	if (gid == 0) {
+		struct group *ugroup = getgrnam(value);
+                if (ugroup)
+                	gid = ugroup->gr_gid;
+	}
+        if (gid <= 0) {
+                uwsgi_log("uwsgi_opt_set_immediate_gid(): invalid gid %d\n", (int) gid);
+                exit(1);
+        }
+        if (setgid(gid)) {
+                uwsgi_error("uwsgi_opt_set_immediate_gid()/setgid()");
+                exit(1);
+        }
+
+	if (setgroups(0, NULL)) {
+        	uwsgi_error("uwsgi_opt_set_immediate_gid()/setgroups()");
+                exit(1);
+        }
+
+	gid = getgid();
+	if (!gid) {
+		exit(1);
+	}
+	uwsgi_log("immediate gid: %d\n", (int) gid);
+}
+
+
+void uwsgi_opt_set_immediate_uid(char *opt, char *value, void *none) {
+	uid_t uid = atoi(value);
+	if (uid == 0) {
+		struct passwd *upasswd = getpwnam(value);
+                if (upasswd)
+                        uid = upasswd->pw_uid;
+	}
+	if (uid <= 0) {
+		uwsgi_log("uwsgi_opt_set_immediate_uid(): invalid uid %d\n", uid);
+		exit(1);
+	}
+	if (setuid(uid)) {
+		uwsgi_error("uwsgi_opt_set_immediate_uid()/setuid()");
+		exit(1);
+	}
+
+	uid = getuid();
+	if (!uid) {
+		exit(1);
+	}
+	uwsgi_log("immediate uid: %d\n", (int) uid);
+}
+
+
 void uwsgi_opt_set_int(char *opt, char *value, void *key) {
 	int *ptr = (int *) key;
 	if (value) {
@@ -3764,6 +3824,9 @@ void uwsgi_opt_load(char *opt, char *filename, void *none) {
 		return;
 	}
 #endif
+
+	// fallback to pluggable system
+	uwsgi_opt_load_config(opt, filename, none);
 }
 
 void uwsgi_opt_logic(char *opt, char *arg, void *func) {
@@ -3790,6 +3853,21 @@ void uwsgi_opt_load_ini(char *opt, char *filename, void *none) {
 	uwsgi_ini_config(filename, uwsgi.magic_table);
 }
 
+void uwsgi_opt_load_config(char *opt, char *filename, void *none) {
+        struct uwsgi_configurator *uc = uwsgi.configurators;
+        while(uc) {
+                if (uwsgi_endswith(filename, uc->name)) {
+                        config_magic_table_fill(filename, uwsgi.magic_table);
+                        uc->func(filename, uwsgi.magic_table);
+                        return;
+                }
+                uc = uc->next;
+        }
+
+	uwsgi_log("unable to load configuration from %s\n", filename);
+	exit(1);
+}
+
 #ifdef UWSGI_XML
 void uwsgi_opt_load_xml(char *opt, char *filename, void *none) {
 	config_magic_table_fill(filename, uwsgi.magic_table);

examples/config.lua

@@ -0,0 +1,9 @@
+config = {}
+
+config['immediate-uid'] = 'roberto'
+config['immediate-gid'] = 'roberto'
+config['http-socket'] = ':9090'
+config['env'] = { 'FOO=bar', 'TEST=topogigio' }
+config['module'] = 'werkzeug.testapp:test_app'
+
+return config

examples/config2.lua

@@ -0,0 +1,8 @@
+config = {}
+
+config[1] = { ['http-socket']=':9090' }
+config[2] = { ['env']='FOO=bar' }
+config[3] = { ['env']='TEST=topogigio' }
+config[4] = { ['module']='werkzeug.testapp:test_app' }
+
+return config

plugins/cplusplus/base.cc

@@ -1,4 +1,4 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
 
 extern struct uwsgi_server uwsgi;
 
@@ -13,8 +13,9 @@ class FakeClass {
 
 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);
+	uwsgi_response_prepare_headers(wsgi_req, (char *)"200 OK", 6);
+	uwsgi_response_add_content_type(wsgi_req, (char *)"text/html", 9);
+	uwsgi_response_write_body_do(wsgi_req, foobar, foobar_len);
 }
 
 extern "C" int uwsgi_cplusplus_init(){
@@ -27,7 +28,7 @@ extern "C" int uwsgi_cplusplus_request(struct wsgi_request *wsgi_req) {
 	FakeClass *fc;
 
 	// empty request ?
-	if (!wsgi_req->uh.pktsize) {
+	if (!wsgi_req->uh->pktsize) {
                 uwsgi_log( "Invalid request. skip.\n");
 		goto clear;
         }
@@ -55,6 +56,7 @@ clear:
 
 
 extern "C" void uwsgi_cplusplus_after_request(struct wsgi_request *wsgi_req) {
+	// call log_request(wsgi_req) if you want a standard logline
         uwsgi_log("logging c++ request\n");
 }
 

plugins/cplusplus/plugin.c

@@ -1,4 +1,4 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
 
 
 int uwsgi_cplusplus_init(void);

plugins/jvm/uwsgiplugin.py

@@ -1,4 +1,5 @@
-import os,sys
+import os
+import shutil
 
 NAME='jvm'
 

plugins/lua/lua_plugin.c

@@ -10,6 +10,7 @@ struct uwsgi_lua {
 	struct lua_State **L;
 
 	char *filename;
+	struct uwsgi_string_list *load;
 } ulua;
 
 #define lca(L, n)		ulua_check_args(L, __FUNCTION__, n)
@@ -17,6 +18,7 @@ struct uwsgi_lua {
 static struct uwsgi_option uwsgi_lua_options[] = {
 
 	{"lua", required_argument, 0, "load lua wsapi app", uwsgi_opt_set_str, &ulua.filename, 0},
+	{"lua-load", required_argument, 0, "load a lua file", uwsgi_opt_add_string_list, &ulua.load, 0},
 
 	{0, 0, 0, 0},
 
@@ -69,7 +71,7 @@ static int uwsgi_api_register_rpc(lua_State *L) {
 	lua_pushvalue(L, 2);
         func = luaL_ref(L, LUA_REGISTRYINDEX);
 
-	uwsgi_log("registered function %d in global table\n", func);
+	uwsgi_log("registered function %d in Lua global table\n", func);
 	lfunc = func;
 
         if (uwsgi_register_rpc((char *)name, 6, 0, (void *) lfunc)) {
@@ -387,36 +389,48 @@ static int uwsgi_lua_init(){
 static void uwsgi_lua_app() {
 	int i;
 
-	if (ulua.filename) {
+	if (!ulua.filename && !ulua.load) return;
+
 		for(i=0;i<uwsgi.cores;i++) {
 			ulua.L[i] = luaL_newstate();
 			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: %s\n", ulua.filename, lua_tostring(ulua.L[i], -1));
-				exit(1);
+
+			struct uwsgi_string_list *usl = ulua.load;
+			while(usl) {
+				if (luaL_dofile(ulua.L[i], usl->value)) {
+                                        uwsgi_log("unable to load Lua file %s: %s\n", usl->value, lua_tostring(ulua.L[i], -1));
+                                        exit(1);
+                                }
+				usl = usl->next;
 			}
+
+			if (ulua.filename) {
+				if (luaL_loadfile(ulua.L[i], ulua.filename)) {
+					uwsgi_log("unable to load Lua file %s: %s\n", ulua.filename, lua_tostring(ulua.L[i], -1));
+					exit(1);
+				}
 			
-			// use a pcall
-			//lua_call(ulua.L[i], 0, 1);
-			if (lua_pcall(ulua.L[i], 0, 1, 0) != 0) {
-				uwsgi_log("%s\n", lua_tostring(ulua.L[i], -1));
-				exit(1);
-			}
+				// use a pcall
+				//lua_call(ulua.L[i], 0, 1);
+				if (lua_pcall(ulua.L[i], 0, 1, 0) != 0) {
+					uwsgi_log("%s\n", lua_tostring(ulua.L[i], -1));
+					exit(1);
+				}
 			
-			// if the loaded lua app returns as a table, fetch the
-			// run function.
-			if (lua_istable(ulua.L[i], 2)) {
-				lua_pushstring(ulua.L[i], "run" );
-				lua_gettable(ulua.L[i], 2);
-				lua_replace(ulua.L[i], 2);
-			}
+				// if the loaded lua app returns as a table, fetch the
+				// run function.
+				if (lua_istable(ulua.L[i], 2)) {
+					lua_pushstring(ulua.L[i], "run" );
+					lua_gettable(ulua.L[i], 2);
+					lua_replace(ulua.L[i], 2);
+				}
 					
-			if (! lua_isfunction(ulua.L[i], 2))	{
-				uwsgi_log("Can't find WSAPI entry point (no function, nor a table with function'run').\n");
-				exit(1);
+				if (! lua_isfunction(ulua.L[i], 2))	{
+					uwsgi_log("Can't find WSAPI entry point (no function, nor a table with function'run').\n");
+					exit(1);
+				}
 			}
-		}
 
 	}
 }
@@ -665,13 +679,92 @@ static uint16_t uwsgi_lua_rpc(void * func, uint8_t argc, char **argv, uint16_t a
 #endif
 	if (sl <= 0xffff) {
 		memcpy(buffer, sv, sl);
+		lua_pop(L, 1);
 		return sl;
 	}
 
+	lua_pop(L, 1);
         return 0;
 
 }
 
+static void uwsgi_lua_configurator_array(lua_State *L) { 
+
+	int i;
+	int n = luaL_getn(L, -3);
+
+	for(i=1;i<=n;i++) {
+		lua_rawgeti(L, 1, i);
+		if (lua_istable(L, -1)) {
+                	lua_pushnil(L);
+                        while (lua_next(L, -2) != 0) {
+                        	char *key = uwsgi_str((char *)lua_tostring(L, -2));
+                                char *value = uwsgi_str((char *)lua_tostring(L, -1));
+                                add_exported_option(key, value, 0);
+                                lua_pop(L, 1);
+                        }
+                }
+	}
+}
+
+
+static void uwsgi_lua_configurator(char *filename, char *magic_table[]) {
+	size_t len = 0;
+	uwsgi_log_initial("[uWSGI] getting Lua configuration from %s\n", filename);
+	char *code = uwsgi_open_and_read(filename, &len, 1, magic_table);
+	lua_State *L = luaL_newstate();
+	if (!L) {
+		uwsgi_log("unable to initialize Lua state for configuration\n");
+		exit(1);
+	}
+        luaL_openlibs(L);
+	if (luaL_dostring(L, code) != 0) {
+		uwsgi_log("error running Lua configurator: %s\n", lua_tostring(L, -1));
+		exit(1);
+	}
+	free(code);
+
+	if (!lua_istable(L, -1)) {
+		uwsgi_log("Lua configurator has to return a table !!!\n");
+		exit(1);
+	}
+
+	lua_pushnil(L);
+	// we always use uwsgi_str to avoid GC destroying our strings
+	// and to be able to call lua_close at the end
+	while (lua_next(L, -2) != 0) {
+		// array ?
+		if (lua_isnumber(L, -2)) {
+			uwsgi_lua_configurator_array(L);
+			break;
+		}
+		// dictionary
+		else {
+			char *key = uwsgi_str((char *)lua_tostring(L, -2));
+			if (lua_istable(L, -1)) {
+				lua_pushnil(L);
+				while (lua_next(L, -2) != 0) {
+					char *value = uwsgi_str((char *)lua_tostring(L, -1));
+					add_exported_option(key, value, 0);
+					lua_pop(L, 1);
+				}	
+			}
+			else {
+				char *value = uwsgi_str((char *)lua_tostring(L, -1));
+				add_exported_option(key, value, 0);
+			}
+		}
+		lua_pop(L, 1);
+	}
+
+	// this will destroy the whole Lua state
+	lua_close(L);
+}
+
+static void uwsgi_register_lua_features() {
+	uwsgi_register_configurator(".lua", uwsgi_lua_configurator);
+}
+
 
 struct uwsgi_plugin lua_plugin = {
 
@@ -688,5 +781,6 @@ struct uwsgi_plugin lua_plugin = {
 	.code_string = uwsgi_lua_code_string,
 	.rpc = uwsgi_lua_rpc,
 
+	.on_load = uwsgi_register_lua_features,
 };
 

plugins/php/php_plugin.c

@@ -96,7 +96,7 @@ static int sapi_uwsgi_send_headers(sapi_headers_struct *sapi_headers)
 	}
 	else {
 		char *sl = SG(sapi_headers).http_status_line;
-		uwsgi_response_prepare_headers(wsgi_req, sl, strlen(sl));
+		uwsgi_response_prepare_headers(wsgi_req, sl + 8 , strlen(sl) - 8);
 	}
 	
 	h = zend_llist_get_first_ex(&sapi_headers->headers, &pos);

plugins/psgi/psgi_plugin.c

@@ -513,6 +513,10 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
 
 	log_request(wsgi_req);
 
+	// We may be called after an early exit in XS_coroae_accept_request, 
+	// before the environ is set up.
+	if (!wsgi_req->async_environ) return;
+
 	// dereference %env
 	SV *env = SvRV((SV *) wsgi_req->async_environ);
 
@@ -664,7 +668,7 @@ void uwsgi_perl_run_hook(SV *hook) {
 }
 
 static void uwsgi_perl_atexit() {
-	if (uwsgi.mywid == -1) goto realstuff;
+	if (uwsgi.mywid == 0) goto realstuff;
 
         // if hijacked do not run atexit hooks
         if (uwsgi.workers[uwsgi.mywid].hijacked)

plugins/python/python_plugin.c

@@ -290,7 +290,7 @@ void uwsgi_python_reset_random_seed() {
 
 void uwsgi_python_atexit() {
 
-	if (uwsgi.mywid == -1) goto realstuff;
+	if (uwsgi.mywid == 0) goto realstuff;
 
 	// if hijacked do not run atexit hooks
 	if (uwsgi.workers[uwsgi.mywid].hijacked)

plugins/rpc/rpc_plugin.c

@@ -93,14 +93,164 @@ end:
 	return ret;
 }
 
+static int uwsgi_routing_func_rpc_blob(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        int ret = -1;
+        // this is the list of args
+        char *argv[UMAX8];
+        // this is the size of each argument
+        uint16_t argvs[UMAX8];
+        // this is a placeholder for tmp uwsgi_buffers
+        struct uwsgi_buffer *ubs[UMAX8];
+
+        char **r_argv = (char **) ur->data2;
+        uint16_t *r_argvs = (uint16_t *) ur->data3;
+
+        char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
+        uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
+
+        uint64_t i;
+        for(i=0;i<ur->custom;i++) {
+                ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);
+                if (!ubs[i]) goto end;
+                argv[i] = ubs[i]->buf;
+                argvs[i] = ubs[i]->pos;
+        }
+
+        // ok we now need to check it it is a local call or a remote one
+        char *func = uwsgi_str(ur->data);
+        char *remote = NULL;
+        char *at = strchr(func, '@');
+        if (at) {
+                *at = 0;
+                remote = at+1;
+        }
+        uint16_t size;
+        char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
+        free(func);
+        if (!response) goto end;
+
+        ret = UWSGI_ROUTE_NEXT;
+
+	// optimization
+	if (!wsgi_req->headers_sent) {
+        	if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {free(response) ; goto end;}
+        	if (uwsgi_response_add_connection_close(wsgi_req)) {free(response) ; goto end;}
+	}
+        uwsgi_response_write_body_do(wsgi_req, response, size);
+        free(response);
+
+end:
+        for(i=0;i<ur->custom;i++) {
+                if (ubs[i] != NULL) {
+                        uwsgi_buffer_destroy(ubs[i]);
+                }
+        }
+        return ret;
+}
+
+
+// "next" || "continue" || "break(.*)" || "goon" || "goto .+"
+static int uwsgi_routing_func_rpc_ret(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        int ret = -1;
+        // this is the list of args
+        char *argv[UMAX8];
+        // this is the size of each argument
+        uint16_t argvs[UMAX8];
+        // this is a placeholder for tmp uwsgi_buffers
+        struct uwsgi_buffer *ubs[UMAX8];
+
+        char **r_argv = (char **) ur->data2;
+        uint16_t *r_argvs = (uint16_t *) ur->data3;
+
+        char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
+        uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
+
+        uint64_t i;
+        for(i=0;i<ur->custom;i++) {
+                ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);
+                if (!ubs[i]) goto end;
+                argv[i] = ubs[i]->buf;
+                argvs[i] = ubs[i]->pos;
+        }
+
+        // ok we now need to check it it is a local call or a remote one
+        char *func = uwsgi_str(ur->data);
+        char *remote = NULL;
+        char *at = strchr(func, '@');
+        if (at) {
+                *at = 0;
+                remote = at+1;
+        }
+        uint16_t size;
+        char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
+        free(func);
+        if (!response) goto end;
+
+        ret = UWSGI_ROUTE_CONTINUE;
+	if (!uwsgi_strncmp(response, size, "next", 4 )) {
+        	ret = UWSGI_ROUTE_NEXT;
+	}
+	else if (!uwsgi_strncmp(response, size, "continue", 8 )) {
+        	ret = UWSGI_ROUTE_CONTINUE;
+	}
+	else if (!uwsgi_strncmp(response, size, "goon", 4 )) {
+        	ret = UWSGI_ROUTE_GOON;
+	}
+	else if (!uwsgi_starts_with(response, size, "break", 5 )) {
+        	ret = UWSGI_ROUTE_BREAK;
+		if (size > 6) {
+			if (uwsgi_response_prepare_headers(wsgi_req, response+6, size-6)) goto end0;
+                	if (uwsgi_response_add_connection_close(wsgi_req)) goto end0;
+                	if (uwsgi_response_add_content_type(wsgi_req, "text/plain", 10)) goto end0;
+                	// no need to check for return value
+                	uwsgi_response_write_headers_do(wsgi_req);
+		}
+	}
+	else if (!uwsgi_starts_with(response, size, "goto ", 5)) {
+		ret = UWSGI_ROUTE_BREAK;
+		if (size > 5) {
+		 	// find the label
+        		struct uwsgi_route *routes = uwsgi.routes;
+        		while(routes) {
+                		if (!routes->label) goto next;
+                		if (!uwsgi_strncmp(routes->label, routes->label_len, response+5, size-5)) {
+					ret = UWSGI_ROUTE_NEXT;
+                        		wsgi_req->route_goto = routes->pos;
+                        		goto found;
+                		}
+next:
+               			routes = routes->next;
+        		}
+			goto end0;	
+found:
+        		if (wsgi_req->route_goto <= wsgi_req->route_pc) {
+                		wsgi_req->route_goto = 0;
+                		uwsgi_log("[uwsgi-route] ERROR \"goto\" instruction can only jump forward (check your label !!!)\n");
+				ret = UWSGI_ROUTE_BREAK;
+        		}
+		}
+	}
+
+end0:
+        free(response);
+
+end:
+        for(i=0;i<ur->custom;i++) {
+                if (ubs[i] != NULL) {
+                        uwsgi_buffer_destroy(ubs[i]);
+                }
+        }
+        return ret;
+}
+
+
 /*
 	ur->data = the func name
         ur->custom = the number of arguments
 	ur->data2 = the pointer to the args
 	ur->data3 = the pointer to the args sizes
 */
-static int uwsgi_router_rpc(struct uwsgi_route *ur, char *args) {
-        ur->func = uwsgi_routing_func_rpc;
+static int uwsgi_router_rpc_base(struct uwsgi_route *ur, char *args) {
 	ur->custom = 0;
 	ur->data2 = uwsgi_calloc(sizeof(char *) * UMAX8);
 	ur->data3 = uwsgi_calloc(sizeof(uint16_t) * UMAX8);
@@ -134,9 +284,28 @@ static int uwsgi_router_rpc(struct uwsgi_route *ur, char *args) {
 	return 0;
 }
 
+static int uwsgi_router_rpc(struct uwsgi_route *ur, char *args) {
+        ur->func = uwsgi_routing_func_rpc;
+	return uwsgi_router_rpc_base(ur, args);
+}
+
+static int uwsgi_router_rpc_ret(struct uwsgi_route *ur, char *args) {
+        ur->func = uwsgi_routing_func_rpc_ret;
+	return uwsgi_router_rpc_base(ur, args);
+}
+
+static int uwsgi_router_rpc_blob(struct uwsgi_route *ur, char *args) {
+        ur->func = uwsgi_routing_func_rpc_blob;
+        return uwsgi_router_rpc_base(ur, args);
+}
+
+
 static void router_rpc_register() {
         uwsgi_register_router("call", uwsgi_router_rpc);
         uwsgi_register_router("rpc", uwsgi_router_rpc);
+        uwsgi_register_router("rpcret", uwsgi_router_rpc_ret);
+        uwsgi_register_router("rpcblob", uwsgi_router_rpc_blob);
+        uwsgi_register_router("rpcnext", uwsgi_router_rpc_blob);
 }
 #endif
 

plugins/v8/plugin.c

@@ -0,0 +1,29 @@
+#include <uwsgi.h>
+
+int uwsgi_v8_init(void);
+void uwsgi_v8_apps(void);
+void uwsgi_v8_configurator(char *, char **);
+uint16_t uwsgi_v8_rpc(void *, uint8_t, char **, uint16_t *, char *);
+int uwsgi_v8_signal_handler(uint8_t, void *);
+
+static void uwsgi_v8_register(void) {
+        uwsgi_register_configurator(".js", uwsgi_v8_configurator);
+}
+
+extern struct uwsgi_option uwsgi_v8_options[];
+
+static int uwsgi_v8_request(struct wsgi_request *wsgi_req) {
+	return UWSGI_OK;
+}
+
+struct uwsgi_plugin v8_plugin = {
+	.name = "v8",
+	.modifier1 = 24,
+	.init = uwsgi_v8_init,
+	.init_apps = uwsgi_v8_apps,
+	.options = uwsgi_v8_options,
+	.on_load = uwsgi_v8_register,
+	.rpc = uwsgi_v8_rpc,
+	.request = uwsgi_v8_request,
+	.signal_handler = uwsgi_v8_signal_handler,
+};

plugins/v8/uwsgiplugin.py

@@ -0,0 +1,6 @@
+NAME='v8'
+
+CFLAGS = []
+LDFLAGS = []
+LIBS = ['-lv8']
+GCC_LIST = ['plugin', 'v8_uwsgi.cc']

plugins/v8/v8_uwsgi.cc

@@ -0,0 +1,237 @@
+#include <uwsgi.h>
+#include <v8.h>
+
+struct uwsgi_v8 {
+        v8::Persistent<v8::Context> *contexts;
+        struct uwsgi_string_list *load;
+} uv8;
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_plugin v8_plugin;
+
+struct uwsgi_option uwsgi_v8_options[] = {
+        {(char *)"v8-load", required_argument, 0, (char *)"load a javascript file", uwsgi_opt_add_string_list, &uv8.load, 0},
+        {0, 0, 0, 0},
+};
+
+static v8::Handle<v8::Value> uwsgi_v8_api_register_signal(const v8::Arguments& args) {
+
+        if (args.Length() > 2) {
+		uint8_t uwsgi_signal = args[0]->Uint32Value();
+		v8::String::Utf8Value signal_kind(args[1]->ToString());
+
+		v8::Persistent<v8::Function> func = v8::Persistent<v8::Function>::New(v8::Handle<v8::Function>::Cast(args[2]));
+
+		if (uwsgi_register_signal(uwsgi_signal, *signal_kind, *func, v8_plugin.modifier1)) {
+			uwsgi_log("[uwsgi-v8] unable to register signal %d\n", uwsgi_signal);
+			return v8::Undefined();
+		}
+		
+		return v8::True();
+        }
+
+        return v8::Undefined();
+}
+
+static v8::Handle<v8::Value> uwsgi_v8_api_register_rpc(const v8::Arguments& args) {
+
+        if (args.Length() > 1) {
+		v8::String::Utf8Value name(args[0]->ToString());
+		uint8_t j_argc = 0;
+		if (args.Length() > 2) {
+			j_argc = args[2]->Uint32Value();
+		}
+
+		v8::Persistent<v8::Function> func = v8::Persistent<v8::Function>::New(v8::Handle<v8::Function>::Cast(args[1]));
+
+		if (uwsgi_register_rpc(*name, v8_plugin.modifier1, j_argc, *func)) {
+			uwsgi_log("[uwsgi-v8] unable to register RPC function \"%s\"\n", *name);
+			return v8::Undefined();
+		}
+
+		return v8::True();
+        }
+
+        return v8::Undefined();
+}
+
+static void uwsgi_v8_load_file(v8::Persistent<v8::Context> context, char *filename) {
+
+	v8::HandleScope handle_scope;
+
+	v8::Context::Scope context_scope(context);
+	
+	size_t len = 0;
+	char *code = uwsgi_open_and_read(filename, &len, 1, NULL);
+
+        // we do not use TryCatch as we directly use stderr and simply exit with error code 1
+        v8::Handle<v8::Script> script = v8::Script::Compile( v8::String::New(code), v8::String::New(filename) );
+        free(code);
+        if (script.IsEmpty()) {
+		exit(1);
+        }
+
+        v8::Handle<v8::Value> result = script->Run();
+        if (result.IsEmpty()) {
+		exit(1);
+        }
+
+}
+
+extern "C" int uwsgi_v8_init(){
+        uwsgi_log("Initializing V8 %s environment... (%d Isolates)\n", v8::V8::GetVersion(), uwsgi.cores);
+        uv8.contexts = (v8::Persistent<v8::Context> *) uwsgi_malloc( sizeof(v8::Persistent<v8::Context>*) * uwsgi.cores );
+        return 0;
+}
+
+static v8::Handle<v8::Value> uwsgi_v8_api_log(const v8::Arguments& args) {
+ 
+	if (args.Length() > 0) {
+		v8::String::Utf8Value str(args[0]->ToString());
+		size_t slen = strlen(*str);
+		if ((*str)[slen-1] == '\n') {
+			uwsgi_log("%s", *str);
+		}
+		else {
+			uwsgi_log("%s\n", *str);
+		}
+	}
+	return v8::Undefined();
+}
+
+static v8::Persistent<v8::Context> uwsgi_v8_new_isolate(int core) {
+	v8::HandleScope handle_scope;
+	if (core > 0) {
+        	// create a new isolate
+        	v8::Isolate *isolate = v8::Isolate::New();
+        	// set as the current isolate
+        	v8::Isolate::Scope iscope(isolate);
+	}
+
+	v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
+	// print alias is always handy
+	global->Set(v8::String::New("uwsgi_log"), v8::FunctionTemplate::New(uwsgi_v8_api_log));
+	global->Set(v8::String::New("uwsgi_register_rpc"), v8::FunctionTemplate::New(uwsgi_v8_api_register_rpc));
+	global->Set(v8::String::New("uwsgi_register_signal"), v8::FunctionTemplate::New(uwsgi_v8_api_register_signal));
+
+        // create a new context
+        v8::Persistent<v8::Context> context = v8::Context::New(NULL, global);
+	return context;
+}
+
+extern "C" void uwsgi_v8_apps() {
+
+        if (!uv8.load) return;
+
+        int i;
+        for(i=0;i<uwsgi.cores;i++) {
+                uv8.contexts[i] = uwsgi_v8_new_isolate(i);
+                struct uwsgi_string_list *usl = uv8.load;
+                while(usl) {
+                        uwsgi_v8_load_file(uv8.contexts[i], usl->value);
+                        usl = usl->next;
+                }
+        }
+}
+
+extern "C" void uwsgi_v8_configurator(char *filename, char *magic_table[]) {
+
+	v8::HandleScope handle_scope;
+
+	uwsgi_log_initial("[uWSGI] getting javascript (V8) configuration from %s\n", filename);
+
+	size_t len = 0;
+	char *code = uwsgi_open_and_read(filename, &len, 1, NULL);
+
+	v8::Handle<v8::Context> context = v8::Context::New();
+
+	v8::Context::Scope context_scope(context);
+
+	// we do not use TryCatch as we directly use stderr and simply exit with error code 1
+	
+	v8::Handle<v8::Script> script = v8::Script::Compile( v8::String::New(code), v8::String::New(filename) );
+	if (script.IsEmpty()) {
+		exit(1);
+	}
+	free(code);
+
+	v8::Handle<v8::Value> result = script->Run();
+	if (result.IsEmpty()) {
+		exit(1);
+	}
+
+	if (!result->IsArray() && !result->IsObject()) {
+		uwsgi_log("javascript return value must be an object or an array !!!\n");
+		exit(1);
+	}
+
+	uint32_t i;
+	const v8::Local<v8::Array> props = result->ToObject()->GetPropertyNames();
+	const uint32_t l = props->Length();
+
+	for(i=0;i<l;i++) {
+		const v8::Local<v8::Value> key = props->Get(i);	
+		const v8::Local<v8::Value> value = result->ToObject()->Get(key);	
+		v8::String::Utf8Value c_key(key->ToString());
+		if (value->IsArray()) {
+			uint32_t opt_l = value->ToObject()->Get(v8::String::New("length"))->ToObject()->Uint32Value();
+			uint32_t j;
+			for(j=0;j<opt_l;j++) {
+				v8::String::Utf8Value c_value(value->ToObject()->Get(j)->ToString());
+				add_exported_option(uwsgi_str(*c_key), uwsgi_str(*c_value), 0);
+			}
+		}
+		else {
+			v8::String::Utf8Value c_value(value->ToString());
+			add_exported_option(uwsgi_str(*c_key), uwsgi_str(*c_value), 0);
+		}
+	}
+	
+}
+
+extern "C" uint16_t uwsgi_v8_rpc(void * func, uint8_t argc, char **argv, uint16_t argvs[], char *buffer) {
+
+	v8::HandleScope handle_scope;
+	
+	v8::Handle<v8::Value> argj[256];
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+
+        v8::Context::Scope context_scope(uv8.contexts[wsgi_req->async_id]);
+
+
+	v8::Persistent<v8::Function> l_func = static_cast<v8::Function*> (func);
+
+	uint8_t i;
+	for(i=0;i<argc;i++) {
+		argj[i] = v8::String::New(argv[i], argvs[i]);
+	}
+
+	v8::Handle<v8::Value> result = l_func->Call(l_func, argc, argj);
+	if (result.IsEmpty()) return 0;
+
+	v8::Handle<v8::String> robj = result->ToString();
+	
+	v8::String::Utf8Value r_value(robj);
+	if (!*robj) return 0;
+	uint16_t rlen = robj->Length();
+	memcpy(buffer, *r_value, rlen);
+	// call GC every time, could be overkill, we should allow to tune that choice
+	while(!v8::V8::IdleNotification()) {};
+        return rlen;
+
+}
+
+extern "C" int uwsgi_v8_signal_handler(uint8_t sig, void *handler) {
+	int ret = 0;
+	v8::HandleScope handle_scope;
+	struct wsgi_request *wsgi_req = current_wsgi_req();
+	v8::Context::Scope context_scope(uv8.contexts[wsgi_req->async_id]);
+	v8::Persistent<v8::Function> l_func = static_cast<v8::Function*> (handler);
+	v8::Handle<v8::Value> argj[1];
+	argj[0] = v8::Number::New(sig);
+	v8::Handle<v8::Value> result = l_func->Call(l_func, 1, argj);
+	if (result.IsEmpty()) ret = -1;
+	while(!v8::V8::IdleNotification()) {};
+	return ret;
+}

uwsgi.gemspec

@@ -2,7 +2,7 @@ Gem::Specification.new do |s|
   s.name        = 'uwsgi'
   s.license     = 'GPL-2'
   s.version     = `python -c "import uwsgiconfig as uc; print uc.uwsgi_version"`.sub(/-dev-.*/,'')
-  s.date        = '2013-03-26'
+  s.date        = '2013-03-30'
   s.summary     = "uWSGI"
   s.description = "The uWSGI server for Ruby/Rack"
   s.authors     = ["Unbit"]

uwsgi.h

@@ -597,6 +597,9 @@ struct uwsgi_legion_node {
 	int quorum;
 	int changed;
 
+	// set to 1 first time when quorum is reached
+	int joined;
+
 	uint64_t checksum;
 
 	char *scroll;
@@ -634,6 +637,7 @@ struct uwsgi_legion_node {
 	struct uwsgi_string_list *unlord_hooks;
 	struct uwsgi_string_list *setup_hooks;
 	struct uwsgi_string_list *death_hooks;
+	struct uwsgi_string_list *join_hooks;
 	struct uwsgi_legion *next;
 	};
 
@@ -832,9 +836,9 @@ struct uwsgi_cache {
 	struct uwsgi_loop *next;
 	};
 
-	struct wsgi_request;
+struct wsgi_request;
 
-	struct uwsgi_socket {
+struct uwsgi_socket {
 	int fd;
 	char *name;
 	int name_len;
@@ -904,11 +908,11 @@ struct uwsgi_cache {
 	int lazy;
 	int shared;
 	int from_shared;
-	};
+};
 
-	struct uwsgi_server;
+struct uwsgi_server;
 
-	struct uwsgi_plugin {
+struct uwsgi_plugin {
 
 	const char *name;
 	const char *alias;
@@ -949,7 +953,7 @@ struct uwsgi_cache {
 
 	int (*spooler) (char *, char *, uint16_t, char *, size_t);
 
-	 uint16_t(*rpc) (void *, uint8_t, char **, uint16_t *, char *);
+	uint16_t(*rpc) (void *, uint8_t, char **, uint16_t *, char *);
 
 	void (*jail) (int (*)(void *), char **);
 	void (*before_privileges_drop) (void);
@@ -959,13 +963,12 @@ struct uwsgi_cache {
 
 	void (*master_cleanup) (void);
 
-
 	struct uwsgi_buffer* (*backtrace)(struct wsgi_request *);
-                struct uwsgi_buffer* (*exception_class)(struct wsgi_request *);
-                struct uwsgi_buffer* (*exception_msg)(struct wsgi_request *);
-                struct uwsgi_buffer* (*exception_repr)(struct wsgi_request *);
-                void (*exception_log)(struct wsgi_request *);
-	};
+        struct uwsgi_buffer* (*exception_class)(struct wsgi_request *);
+        struct uwsgi_buffer* (*exception_msg)(struct wsgi_request *);
+        struct uwsgi_buffer* (*exception_repr)(struct wsgi_request *);
+        void (*exception_log)(struct wsgi_request *);
+};
 
 #ifdef UWSGI_PCRE
 int uwsgi_regexp_build(char *, pcre **, pcre_extra **);
@@ -1506,6 +1509,14 @@ struct uwsgi_instance_status {
 	int is_cleaning;
 };
 
+struct uwsgi_configurator {
+	char *name;
+	void (*func)(char *, char **);
+	struct uwsgi_configurator *next;
+};
+struct uwsgi_configurator *uwsgi_register_configurator(char *, void (*)(char *, char **));
+void uwsgi_opt_load_config(char *, char *, void *);
+
 #define uwsgi_instance_is_dying (uwsgi.status.gracefully_destroying || uwsgi.status.brutally_destroying)
 #define uwsgi_instance_is_reloading (uwsgi.status.gracefully_reloading || uwsgi.status.brutally_reloading)
 
@@ -1517,6 +1528,7 @@ struct uwsgi_server {
 	int hostname_len;
 
 	int (*proto_hooks[UWSGI_PROTO_MAX_CHECK]) (struct wsgi_request *, char *, char *, uint16_t);
+	struct uwsgi_configurator *configurators;
 
 	char **orig_argv;
 	char **argv;
@@ -1628,6 +1640,7 @@ struct uwsgi_server {
 	int emperor_fd;
 	int emperor_queue;
 	int emperor_tyrant;
+	int emperor_tyrant_nofollow;
 	int emperor_fd_config;
 	int early_emperor;
 	int emperor_throttle;
@@ -1635,6 +1648,7 @@ struct uwsgi_server {
 	int emperor_max_throttle;
 	int emperor_magic_exec;
 	int emperor_heartbeat;
+	struct uwsgi_string_list *emperor_extra_extension;
 	// search for a file with the specified extension at the same level of the vassal file
 	char *emperor_on_demand_extension;
 	// bind to a unix socket on the specified directory named directory/vassal.socket
@@ -3242,6 +3256,8 @@ void uwsgi_opt_add_spooler(char *, char *, void *);
 void uwsgi_opt_add_daemon(char *, char *, void *);
 void uwsgi_opt_set_uid(char *, char *, void *);
 void uwsgi_opt_set_gid(char *, char *, void *);
+void uwsgi_opt_set_immediate_uid(char *, char *, void *);
+void uwsgi_opt_set_immediate_gid(char *, char *, void *);
 void uwsgi_opt_set_env(char *, char *, void *);
 void uwsgi_opt_unset_env(char *, char *, void *);
 void uwsgi_opt_pidfile_signal(char *, char *, void *);
@@ -3743,9 +3759,12 @@ void uwsgi_user_unlock(int);
 
 #ifdef UWSGI_SSL
 void uwsgi_opt_legion(char *, char *, void *);
+struct uwsgi_legion *uwsgi_legion_register(char *, char *, char *, char *, char *);
 void uwsgi_opt_legion_node(char *, char *, void *);
+void uwsgi_legion_register_node(struct uwsgi_legion *, char *);
 void uwsgi_opt_legion_quorum(char *, char *, void *);
 void uwsgi_opt_legion_hook(char *, char *, void *);
+void uwsgi_legion_register_hook(struct uwsgi_legion *, char *, char *);
 void uwsgi_opt_legion_scroll(char *, char *, void *);
 void uwsgi_legion_add(struct uwsgi_legion *);
 char *uwsgi_ssl_rand(size_t);
@@ -3885,8 +3904,8 @@ char *uwsgi_get_header(struct wsgi_request *, char *, uint16_t, uint16_t *);
 void uwsgi_alarm_thread_start(void);
 void uwsgi_exceptions_handler_thread_start(void);
 
-#define uwsgi_response_add_connection_close(x) uwsgi_response_add_header(x, "Connection", 10, "close", 5)
-#define uwsgi_response_add_content_type(x, y, z) uwsgi_response_add_header(x, "Content-Type", 12, y, z)
+#define uwsgi_response_add_connection_close(x) uwsgi_response_add_header(x, (char *)"Connection", 10, (char *)"close", 5)
+#define uwsgi_response_add_content_type(x, y, z) uwsgi_response_add_header(x, (char *)"Content-Type", 12, y, z)
 
 struct uwsgi_stats_pusher_instance *uwsgi_stats_pusher_add(struct uwsgi_stats_pusher *, char *);
 

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.9.2'
+uwsgi_version = '1.9.4'
 
 import os
 import re
@@ -457,7 +457,7 @@ class uConf(object):
         self.config.readfp(open_profile(filename))
         self.gcc_list = ['core/utils', 'core/protocol', 'core/socket', 'core/logging', 'core/master', 'core/master_utils', 'core/emperor',
             'core/notify', 'core/mule', 'core/subscription', 'core/stats', 'core/sendfile', 'core/async', 'core/master_checks',
-            'core/offload', 'core/io', 'core/static', 'core/websockets', 'core/spooler', 'core/snmp', 'core/exceptions',
+            'core/offload', 'core/io', 'core/static', 'core/websockets', 'core/spooler', 'core/snmp', 'core/exceptions', 'core/config',
             'core/setup_utils', 'core/clock', 'core/init', 'core/buffer', 'core/reader', 'core/writer', 'core/alarm',
             'core/plugins', 'core/lock', 'core/cache', 'core/daemons', 'core/errors', 'core/hash', 'core/master_events',
             'core/queue', 'core/event', 'core/signal', 'core/strings', 'core/progress', 'core/timebomb', 'core/ini',