ready for 2.0.7

Update rados.c

CONTRIBUTORS

@@ -1,7 +1,7 @@
 - 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>
+Riccardo Magliocchetti
 Yann Malet, Lincoln Loop
 Simon Litchfield
 Masahiro Honma, <hiratara@cpan.org>
@@ -28,3 +28,4 @@ Ryan Petrello
 Danila Shtan <danila@shtan.ru>
 Ævar Arnfjörð Bjarmason
 Yu Zhao (getcwd)
+Mathieu Dupuy

core/cache.c

@@ -331,6 +331,14 @@ void uwsgi_cache_init(struct uwsgi_cache *uc) {
 		int cache_fd;
 		struct stat cst;
 
+        if (uc->store_delete && !stat(uc->store, &cst) && ((size_t) cst.st_size != uc->filesize || !S_ISREG(cst.st_mode))) {
+            uwsgi_log("Removing invalid cache store file: %s\n", uc->store);
+            if (unlink(uc->store) != 0) {
+                uwsgi_log("Cannot remove invalid cache store file: %s\n", uc->store);
+                exit(1);
+            }
+        }
+
 		if (stat(uc->store, &cst)) {
 			uwsgi_log("creating a new cache store file: %s\n", uc->store);
 			cache_fd = open(uc->store, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
@@ -733,16 +741,22 @@ int uwsgi_cache_set2(struct uwsgi_cache *uc, char *key, uint16_t keylen, char *v
 		else {
 			uci->first_block = uwsgi_cache_find_free_blocks(uc, vallen);
 			if (uci->first_block == 0xffffffffffffffffLLU) {
-				if (!uc->ignore_full)
-					uwsgi_log("*** DANGER cache \"%s\" is FULL !!! ***\n", uc->name);
+				if (!uc->ignore_full) {
+					if (uc->purge_lru)
+                                        	uwsgi_log("LRU item will be purged from cache \"%s\"\n", uc->name);
+					else
+						uwsgi_log("*** DANGER cache \"%s\" is FULL !!! ***\n", uc->name);
+				}
                                 uc->full++;
 				uc->unused_blocks_stack_ptr++;
+				if (uc->purge_lru && uc->lru_head)
+                                	uwsgi_cache_del2(uc, NULL, 0, uc->lru_head, UWSGI_CACHE_FLAG_LOCAL);
                                 goto end;
 			}
 			// mark used blocks;
 			uint64_t needed_blocks = cache_mark_blocks(uc, uci->first_block, vallen);
 			// optimize the scan
-			if (uc->blocks_bitmap_pos + needed_blocks > uc->blocks) {
+			if (uci->first_block + needed_blocks >= uc->blocks) {
                         	uc->blocks_bitmap_pos = 0;
                         }
                         else {
@@ -837,16 +851,22 @@ int uwsgi_cache_set2(struct uwsgi_cache *uc, char *key, uint16_t keylen, char *v
 			uint64_t old_first_block = uci->first_block;
 			uci->first_block = uwsgi_cache_find_free_blocks(uc, vallen);
                         if (uci->first_block == 0xffffffffffffffffLLU) {
-				if (!uc->ignore_full)
-					uwsgi_log("*** DANGER cache \"%s\" is FULL !!! ***\n", uc->name);
+				if (!uc->ignore_full) {
+                                        if (uc->purge_lru)
+                                                uwsgi_log("LRU item will be purged from cache \"%s\"\n", uc->name);
+                                        else
+                                                uwsgi_log("*** DANGER cache \"%s\" is FULL !!! ***\n", uc->name);
+                                }
                                 uc->full++;
 				uci->first_block = old_first_block;
+				if (uc->purge_lru && uc->lru_head)
+                                        uwsgi_cache_del2(uc, NULL, 0, uc->lru_head, UWSGI_CACHE_FLAG_LOCAL);
                                 goto end;
                         }
                         // mark used blocks;
                         uint64_t needed_blocks = cache_mark_blocks(uc, uci->first_block, vallen);
                         // optimize the scan
-                        if (uc->blocks_bitmap_pos + needed_blocks > uc->blocks) {
+                        if (uci->first_block + needed_blocks >= uc->blocks) {
                                 uc->blocks_bitmap_pos = 0;
                         }
                         else {
@@ -1212,6 +1232,7 @@ struct uwsgi_cache *uwsgi_cache_create(char *arg) {
 		char *c_keysize = NULL;
 		char *c_store = NULL;
 		char *c_store_sync = NULL;
+		char *c_store_delete = NULL;
 		char *c_nodes = NULL;
 		char *c_sync = NULL;
 		char *c_udp_servers = NULL;
@@ -1236,6 +1257,8 @@ struct uwsgi_cache *uwsgi_cache_create(char *arg) {
                         "store", &c_store,
                         "store_sync", &c_store_sync,
                         "storesync", &c_store_sync,
+                        "store_delete", &c_store_delete,
+                        "storedelete", &c_store_delete,
                         "node", &c_nodes,
                         "nodes", &c_nodes,
                         "sync", &c_sync,
@@ -1299,6 +1322,8 @@ struct uwsgi_cache *uwsgi_cache_create(char *arg) {
 		if (c_use_last_modified) uc->use_last_modified = 1;
 		if (c_ignore_full) uc->ignore_full = 1;
 
+		if (c_store_delete) uc->store_delete = 1;
+
 		if (c_math_initial) uc->math_initial = strtol(c_math_initial, NULL, 10);
 
 		uc->store_sync = uwsgi.cache_store_sync;

core/emperor.c

@@ -1015,14 +1015,14 @@ int uwsgi_emperor_vassal_start(struct uwsgi_instance *n_ui) {
 		uwsgi_foreach(usl, uwsgi.mount_as_emperor) {
 			uwsgi_log("mounting \"%s\" (as-emperor for vassal \"%s\" pid: %d uid: %d gid: %d)...\n", usl->value, n_ui->name, n_ui->pid, n_ui->uid, n_ui->gid);
 			if (uwsgi_mount_hook(usl->value)) {
-				exit(1);
+				uwsgi_log("unable to mount %s\n", usl->value);
 			}
 		}
 
 		uwsgi_foreach(usl, uwsgi.umount_as_emperor) {
 			uwsgi_log("un-mounting \"%s\" (as-emperor for vassal \"%s\" pid: %d uid: %d gid: %d)...\n", usl->value, n_ui->name, n_ui->pid, n_ui->uid, n_ui->gid);
 			if (uwsgi_umount_hook(usl->value)) {
-				exit(1);
+				uwsgi_log("unable to umount %s\n", usl->value);
 			}
 		}
 		uwsgi_foreach(usl, uwsgi.exec_as_emperor) {
@@ -1093,7 +1093,20 @@ int uwsgi_emperor_vassal_start(struct uwsgi_instance *n_ui) {
 }
 
 static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
+	int i;
 
+	// run plugin hooks for the vassal
+	for (i = 0; i < 256; i++) {
+                if (uwsgi.p[i]->vassal) {
+                        uwsgi.p[i]->vassal(n_ui);
+                }
+        }
+
+        for (i = 0; i < uwsgi.gp_cnt; i++) {
+                if (uwsgi.gp[i]->vassal) {
+                        uwsgi.gp[i]->vassal(n_ui);
+                }
+        }
 
 #ifdef __linux__
 	if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0)) {
@@ -1350,7 +1363,6 @@ static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
 	}
 
 	// close all of the unneded fd
-	int i;
 	for (i = 3; i < (int) uwsgi.max_fd; i++) {
 		if (uwsgi_fd_is_safe(i))
 			continue;
@@ -1429,10 +1441,24 @@ static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
 		func(n_ui->name, n_ui->uid, n_ui->gid);
 	}
 
+	// ->vassal_before_exec
+	for (i = 0; i < 256; i++) {
+                if (uwsgi.p[i]->vassal_before_exec) {
+                        uwsgi.p[i]->vassal_before_exec(n_ui);
+                }
+        }
+
+        for (i = 0; i < uwsgi.gp_cnt; i++) {
+                if (uwsgi.gp[i]->vassal) {
+                        uwsgi.gp[i]->vassal_before_exec(n_ui);
+                }
+        }
+
 	// start !!!
 	if (execvp(vassal_argv[0], vassal_argv)) {
 		uwsgi_error("execvp()");
 	}
+	uwsgi_log("[emperor] binary path: %s\n", vassal_argv[0]);
 	uwsgi_log("[emperor] is the uwsgi binary in your system PATH ?\n");
 	// never here
 	exit(UWSGI_EXILE_CODE);
@@ -1738,6 +1764,8 @@ void emperor_loop() {
 			if (ui_current) {
 				char byte;
 				ssize_t rlen = read(interesting_fd, &byte, 1);
+				// retry if needed
+				if (rlen < 0 && uwsgi_is_again()) continue;
 				if (rlen <= 0) {
 					// SAFE
 					event_queue_del_fd(uwsgi.emperor_queue, interesting_fd, event_queue_read());
@@ -2322,7 +2350,17 @@ void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char
 
 void uwsgi_master_manage_emperor() {
 	char byte;
+#ifdef UWSGI_EVENT_USE_PORT
+	// special cose for port event system
+	// place the socket in non-blocking mode
+        uwsgi_socket_nb(uwsgi.emperor_fd);
+#endif
 	ssize_t rlen = read(uwsgi.emperor_fd, &byte, 1);
+#ifdef UWSGI_EVENT_USE_PORT
+	// special cose for port event system
+	// and place back in blocking mode
+        uwsgi_socket_b(uwsgi.emperor_fd);
+#endif
 	if (rlen > 0) {
 		uwsgi_log_verbose("received message %d from emperor\n", byte);
 		// remove me
@@ -2342,6 +2380,12 @@ void uwsgi_master_manage_emperor() {
 			uwsgi_unblock_signal(SIGHUP);
 		}
 	}
+#ifdef UWSGI_EVENT_USE_PORT
+        // special cose for port event system
+	else if (rlen < 0 && uwsgi_is_again()) {
+		return;
+	}
+#endif
 	else {
 		uwsgi_error("uwsgi_master_manage_emperor()/read()");
 		uwsgi_log("lost connection with my emperor !!!\n");

core/event.c

@@ -414,11 +414,11 @@ int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
 	}
 
 	if (ret < 0) {
-		if (errno != ETIME) {
-			uwsgi_error("port_getn()");
-			return -1;
-		}
-		return 0;
+		if (errno == ETIME) return 0;
+                if (errno != EINTR) {
+                        uwsgi_error("port_getn()");
+                }
+                return -1;
 	}
 
 	uint_t i;
@@ -452,6 +452,7 @@ int event_queue_wait(int eq, int timeout, int *interesting_fd) {
 	else {
 		ret = port_get(eq, &pe, NULL);
 	}
+
 	if (ret < 0) {
 		if (errno == ETIME) return 0;
 		if (errno != EINTR) {

core/fifo.c

@@ -80,6 +80,7 @@ void uwsgi_master_fifo_prepare() {
 
 	uwsgi_fifo_table['-'] = uwsgi_cheaper_decrease;
 	uwsgi_fifo_table['+'] = uwsgi_cheaper_increase;
+	uwsgi_fifo_table['B'] = vassal_sos; 
 	uwsgi_fifo_table['c'] = uwsgi_chain_reload;
 	uwsgi_fifo_table['C'] = uwsgi_go_cheap;
 	uwsgi_fifo_table['E'] = emperor_rescan;

core/logging.c

@@ -354,51 +354,51 @@ void uwsgi_setup_log() {
 
 static struct uwsgi_logger *setup_choosen_logger(struct uwsgi_string_list *usl) {
 	char *id = NULL;
-                char *name = usl->value;
+	char *name = usl->value;
 
-                char *space = strchr(name, ' ');
-                if (space) {
-                        int is_id = 1;
-                        int i;
-                        for (i = 0; i < (space - name); i++) {
-                                if (!isalnum((int)name[i])) {
-                                        is_id = 0;
-                                        break;
-                                }
-                        }
-                        if (is_id) {
-                                id = uwsgi_concat2n(name, space - name, "", 0);
-                                name = space + 1;
-                        }
-                }
+	char *space = strchr(name, ' ');
+	if (space) {
+		int is_id = 1;
+		int i;
+		for (i = 0; i < (space - name); i++) {
+			if (!isalnum((int)name[i])) {
+				is_id = 0;
+				break;
+			}
+		}
+		if (is_id) {
+			id = uwsgi_concat2n(name, space - name, "", 0);
+			name = space + 1;
+		}
+	}
 
-                char *colon = strchr(name, ':');
-                if (colon) {
-                        *colon = 0;
-                }
+	char *colon = strchr(name, ':');
+	if (colon) {
+		*colon = 0;
+	}
 
-                struct uwsgi_logger *choosen_logger = uwsgi_get_logger(name);
-                if (!choosen_logger) {
-                        uwsgi_log("unable to find logger %s\n", name);
-                        exit(1);
-                }
+	struct uwsgi_logger *choosen_logger = uwsgi_get_logger(name);
+	if (!choosen_logger) {
+		uwsgi_log("unable to find logger %s\n", name);
+		exit(1);
+	}
 
-                // make a copy of the logger
-                struct uwsgi_logger *copy_of_choosen_logger = uwsgi_malloc(sizeof(struct uwsgi_logger));
-                memcpy(copy_of_choosen_logger, choosen_logger, sizeof(struct uwsgi_logger));
-                choosen_logger = copy_of_choosen_logger;
-                choosen_logger->id = id;
-                choosen_logger->next = NULL;
+	// make a copy of the logger
+	struct uwsgi_logger *copy_of_choosen_logger = uwsgi_malloc(sizeof(struct uwsgi_logger));
+	memcpy(copy_of_choosen_logger, choosen_logger, sizeof(struct uwsgi_logger));
+	choosen_logger = copy_of_choosen_logger;
+	choosen_logger->id = id;
+	choosen_logger->next = NULL;
 
-                if (colon) {
-                        choosen_logger->arg = colon + 1;
-                        // check for empty string
-                        if (*choosen_logger->arg == 0) {
-                                choosen_logger->arg = NULL;
-                        }
-                        *colon = ':';
-                }
-		return choosen_logger;
+	if (colon) {
+		choosen_logger->arg = colon + 1;
+		// check for empty string
+		if (*choosen_logger->arg == 0) {
+			choosen_logger->arg = NULL;
+		}
+		*colon = ':';
+	}
+	return choosen_logger;
 }
 
 void uwsgi_setup_log_master(void) {
@@ -519,40 +519,46 @@ void uwsgi_check_logrotate(void) {
 	}
 }
 
-void uwsgi_log_rotate() {
-	if (!uwsgi.logfile) return;
-	char *rot_name = uwsgi.log_backupname;
-                int need_free = 0;
-                if (rot_name == NULL) {
-                        char *ts_str = uwsgi_num2str((int) uwsgi_now());
-                        rot_name = uwsgi_concat3(uwsgi.logfile, ".", ts_str);
-                        free(ts_str);
-                        need_free = 1;
-                }
-		// this will be rawly written to the logfile
-                uwsgi_logfile_write("logsize: %llu, triggering rotation to %s...\n", (unsigned long long) uwsgi.shared->logsize, rot_name);
-                if (rename(uwsgi.logfile, rot_name) == 0) {
-                        // reopen logfile and dup'it, on dup2 error, exit(1)
-                        int fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);
-                        if (fd < 0) {
-				// this will be written to the original file
-                                uwsgi_error_open(uwsgi.logfile);
+void uwsgi_log_do_rotate(char *logfile, char *rotatedfile, off_t logsize, int log_fd) {
+	int need_free = 0;
+	char *rot_name = rotatedfile;
+
+	if (rot_name == NULL) {
+		char *ts_str = uwsgi_num2str((int) uwsgi_now());
+		rot_name = uwsgi_concat3(logfile, ".", ts_str);
+		free(ts_str);
+		need_free = 1;
+	}
+	// this will be rawly written to the logfile
+	uwsgi_logfile_write("logsize: %llu, triggering rotation to %s...\n", (unsigned long long) logsize, rot_name);
+	if (rename(logfile, rot_name) == 0) {
+		// reopen logfile and dup'it, on dup2 error, exit(1)
+		int fd = open(logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);
+		if (fd < 0) {
+			// this will be written to the original file
+			uwsgi_error_open(logfile);
+			exit(1);
+		}
+		else {
+			if (dup2(fd, log_fd) < 0) {
+				// this could be lost :(
+				uwsgi_error("uwsgi_log_do_rotate()/dup2()");
 				exit(1);
-                        }
-                        else {
-                                if (dup2(fd, uwsgi.original_log_fd) < 0) {
-					// this could be lost :(
-                                        uwsgi_error("uwsgi_log_rotate()/dup2()");
-					exit(1);
-                                }
-                                close(fd);
-                        }
-                }
-                else {
-                        uwsgi_error("unable to rotate log: rename()");
-                }
-                if (need_free)
-                        free(rot_name);
+			}
+			close(fd);
+		}
+	}
+	else {
+		uwsgi_error("unable to rotate log: rename()");
+	}
+	if (need_free)
+		free(rot_name);
+}
+
+void uwsgi_log_rotate() {
+	if (!uwsgi.logfile)
+		return;
+	uwsgi_log_do_rotate(uwsgi.logfile, uwsgi.log_backupname, uwsgi.shared->logsize, uwsgi.original_log_fd);
 }
 
 void uwsgi_log_reopen() {

core/master.c

@@ -7,6 +7,7 @@ void uwsgi_update_load_counters() {
 	int i;
 	uint64_t busy_workers = 0;
 	uint64_t idle_workers = 0;
+	static time_t last_sos = 0;
 
         for (i = 1; i <= uwsgi.numproc; i++) {
                 if (uwsgi.workers[i].cheaped == 0 && uwsgi.workers[i].pid > 0) {
@@ -21,6 +22,15 @@ void uwsgi_update_load_counters() {
 
 	if (busy_workers >= (uint64_t) uwsgi.numproc) {
 		ushared->overloaded++;
+	
+		if (uwsgi.vassal_sos) {
+			if (uwsgi.current_time - last_sos > uwsgi.vassal_sos) {
+                        	uwsgi_log_verbose("asking Emperor for reinforcements (overload: %llu)...\n", (unsigned long long) ushared->overloaded);
+				vassal_sos();
+				last_sos = uwsgi.current_time;
+			}
+		}
+
 	}
 
 	ushared->busy_workers = busy_workers;
@@ -273,17 +283,23 @@ static void master_check_listen_queue() {
         if (uwsgi.vassal_sos_backlog > 0 && uwsgi.has_emperor) {
         	if (uwsgi.shared->backlog >= (uint64_t) uwsgi.vassal_sos_backlog) {
                 	// ask emperor for help
-                        char byte = 30;
-                        if (write(uwsgi.emperor_fd, &byte, 1) != 1) {
-                        	uwsgi_error("write()");
-                        }
-                        else {
-                        	uwsgi_log_verbose("asking Emperor for reinforcements (backlog: %llu)...\n", (unsigned long long) uwsgi.shared->backlog);
-                        }
+                        uwsgi_log_verbose("asking Emperor for reinforcements (backlog: %llu)...\n", (unsigned long long) uwsgi.shared->backlog);
+			vassal_sos();
                 }
 	}
 }
 
+void vassal_sos() {
+	if (!uwsgi.has_emperor) {
+		uwsgi_log("[broodlord] instance not governed by an Emperor !!!\n");
+		return;	
+	}
+	char byte = 30;
+        if (write(uwsgi.emperor_fd, &byte, 1) != 1) {
+        	uwsgi_error("vassal_sos()/write()");
+        }
+}
+
 int master_loop(char **argv, char **environ) {
 
 	struct timeval last_respawn;

core/master_utils.c

@@ -1719,6 +1719,7 @@ void uwsgi_setns_preopen() {
         }
         while ((de = readdir(ns)) != NULL) {
                 if (strlen(de->d_name) > 0 && de->d_name[0] == '.') continue;
+		if (!strcmp(de->d_name, "user")) continue;
                 struct uwsgi_string_list *usl = NULL;
                 int found = 0;
                 uwsgi_foreach(usl, uwsgi.setns_socket_skip) {
@@ -1777,6 +1778,7 @@ void uwsgi_master_manage_setns(int fd) {
 	}
 	while ((de = readdir(ns)) != NULL) {
 		if (strlen(de->d_name) > 0 && de->d_name[0] == '.') continue;
+		if (!strcmp(de->d_name, "user")) continue;
 		struct uwsgi_string_list *usl = NULL;
 		int found = 0;
 		uwsgi_foreach(usl, uwsgi.setns_socket_skip) {

core/reader.c

@@ -123,7 +123,7 @@ static int consume_body_for_readline(struct wsgi_request *wsgi_req) {
 
 	// allocate more memory if needed
 	if (wsgi_req->post_readline_size - wsgi_req->post_readline_watermark == 0) {
-		memcpy(wsgi_req->post_readline_buf, wsgi_req->post_readline_buf + wsgi_req->post_readline_pos, wsgi_req->post_readline_watermark - wsgi_req->post_readline_pos);
+		memmove(wsgi_req->post_readline_buf, wsgi_req->post_readline_buf + wsgi_req->post_readline_pos, wsgi_req->post_readline_watermark - wsgi_req->post_readline_pos);
 		wsgi_req->post_readline_watermark -= wsgi_req->post_readline_pos;
 		wsgi_req->post_readline_pos = 0;
 		// still something to use ?

core/rpc.c

@@ -193,12 +193,13 @@ char *uwsgi_do_rpc(char *node, char *func, uint8_t argc, char *argv[], uint16_t
 	close(fd);
 	*len = rlen;
 	if (*len == 0) {
-		goto error;
+		goto error2;
 	}
 	return buffer;
 
 error:
 	close(fd);
+error2:
 	free(buffer);
 	return NULL;
 

core/sendfile.c

@@ -20,9 +20,18 @@ ssize_t uwsgi_sendfile_do(int sockfd, int filefd, size_t pos, size_t len) {
 	int sf_ret = sendfile(filefd, sockfd, pos, &sf_len, NULL, 0);
 	if (sf_ret == 0 || (sf_ret == -1 && errno == EAGAIN)) return sf_len;
 	return -1;
-#elif defined(__linux__) || defined(__sun__) || defined(__GNU_kFreeBSD__)
+#elif defined(__linux__) || defined(__GNU_kFreeBSD__)
 	off_t off = pos;
 	return sendfile(sockfd, filefd, &off, len);
+#elif defined(__sun__)
+	off_t off = pos;
+	ssize_t wlen = sendfile(sockfd, filefd, &off, len);
+	if (wlen < 0 && uwsgi_is_again()) {
+		if (off - pos > 0) {
+			return off-pos;
+		}
+	}
+	return wlen;
 #endif
 
 no_sendfile:

core/spooler.c

@@ -200,11 +200,13 @@ static void spooler_req_parser_hook(char *key, uint16_t key_len, char *value, ui
 	}
 }
 
+/*
+CHANGED in 2.0.7: wsgi_req is useless !
+*/
 char *uwsgi_spool_request(struct wsgi_request *wsgi_req, char *buf, size_t len, char *body, size_t body_len) {
 
 	struct timeval tv;
 	static uint64_t internal_counter = 0;
-	int core_id = 0;
 	int fd = -1;
 	struct spooler_req sr;
 
@@ -232,10 +234,6 @@ char *uwsgi_spool_request(struct wsgi_request *wsgi_req, char *buf, size_t len,
 		}
 	}
 
-	if (wsgi_req) {
-		core_id = wsgi_req->async_id;
-	}
-
 	// this lock is for threads, the pid value in filename will avoid multiprocess races
 	uwsgi_lock(uspool->lock);
 
@@ -260,7 +258,7 @@ char *uwsgi_spool_request(struct wsgi_request *wsgi_req, char *buf, size_t len,
 		// no need to check for errors...
 		(void) mkdir(filename, 0777);
 
-		ret = snprintf(filename, filename_len, "%s/%.*s/uwsgi_spoolfile_on_%s_%d_%llu_%d_%llu_%llu", uspool->dir, (int)sr.priority_len, sr.priority, uwsgi.hostname, (int) getpid(), (unsigned long long) internal_counter, core_id,
+		ret = snprintf(filename, filename_len, "%s/%.*s/uwsgi_spoolfile_on_%s_%d_%llu_%d_%llu_%llu", uspool->dir, (int)sr.priority_len, sr.priority, uwsgi.hostname, (int) getpid(), (unsigned long long) internal_counter, rand(),
 				(unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec);
 		if (ret <= 0 || ret >=(int)  filename_len) {
                         uwsgi_log("[uwsgi-spooler] error generating spooler filename\n");
@@ -272,8 +270,8 @@ char *uwsgi_spool_request(struct wsgi_request *wsgi_req, char *buf, size_t len,
 	else {
 		filename_len = strlen(uspool->dir) + strlen(uwsgi.hostname) + 256;
                 filename = uwsgi_malloc(filename_len);
-		int ret = snprintf(filename, filename_len, "%s/uwsgi_spoolfile_on_%s_%d_%llu_%d_%llu_%llu", uspool->dir, uwsgi.hostname, (int) getpid(), (unsigned long long) internal_counter, core_id,
-				(unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec);
+		int ret = snprintf(filename, filename_len, "%s/uwsgi_spoolfile_on_%s_%d_%llu_%d_%llu_%llu", uspool->dir, uwsgi.hostname, (int) getpid(), (unsigned long long) internal_counter,
+				rand(), (unsigned long long) tv.tv_sec, (unsigned long long) tv.tv_usec);
 		if (ret <= 0 || ret >= (int) filename_len) {
                         uwsgi_log("[uwsgi-spooler] error generating spooler filename\n");
 			free(filename);

core/utils.c

@@ -1019,8 +1019,14 @@ void uwsgi_destroy_request(struct wsgi_request *wsgi_req) {
                 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &foo);
         }
 
-        memset(wsgi_req, 0, sizeof(struct wsgi_request));
+	// reset for avoiding following requests to fail on non-uwsgi protocols
+	// thanks Marko Tiikkaja for catching it
+	wsgi_req->uh->pktsize = 0;
 
+	// some plugins expected async_id to be defined before setup
+        int tmp_id = wsgi_req->async_id;
+        memset(wsgi_req, 0, sizeof(struct wsgi_request));
+        wsgi_req->async_id = tmp_id;
 }
 
 // finalize/close/free a request
@@ -1166,8 +1172,8 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 	wsgi_req->uh->pktsize = 0;
 	tmp_id = wsgi_req->async_id;
 	memset(wsgi_req, 0, sizeof(struct wsgi_request));
+	// some plugins expected async_id to be defined before setup
 	wsgi_req->async_id = tmp_id;
-
 	// yes, this is pretty useless but we cannot ensure all of the plugin have the same behaviour
 	uwsgi.workers[uwsgi.mywid].cores[wsgi_req->async_id].in_request = 0;
 

core/uwsgi.c

@@ -71,8 +71,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 
 	{"protocol", required_argument, 0, "force the specified protocol for default sockets", uwsgi_opt_set_str, &uwsgi.protocol, 0},
 	{"socket-protocol", required_argument, 0, "force the specified protocol for default sockets", uwsgi_opt_set_str, &uwsgi.protocol, 0},
-	{"shared-socket", required_argument, 0, "create a shared sacket for advanced jailing or ipc", uwsgi_opt_add_shared_socket, NULL, 0},
-	{"undeferred-shared-socket", required_argument, 0, "create a shared sacket for advanced jailing or ipc (undeferred mode)", uwsgi_opt_add_shared_socket, NULL, 0},
+	{"shared-socket", required_argument, 0, "create a shared socket for advanced jailing or ipc", uwsgi_opt_add_shared_socket, NULL, 0},
+	{"undeferred-shared-socket", required_argument, 0, "create a shared socket for advanced jailing or ipc (undeferred mode)", uwsgi_opt_add_shared_socket, NULL, 0},
 	{"processes", required_argument, 'p', "spawn the specified number of workers/processes", uwsgi_opt_set_int, &uwsgi.numproc, 0},
 	{"workers", required_argument, 'p', "spawn the specified number of workers/processes", uwsgi_opt_set_int, &uwsgi.numproc, 0},
 	{"thunder-lock", no_argument, 0, "serialize accept() usage (if possible)", uwsgi_opt_true, &uwsgi.use_thunder_lock, 0},
@@ -241,6 +241,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"vassals-include-before", required_argument, 0, "include config templates to vassals config (uses --include instead of --inherit, parses before the vassal file)", uwsgi_opt_add_string_list, &uwsgi.vassals_includes_before, 0},
 	{"vassals-start-hook", required_argument, 0, "run the specified command before each vassal starts", uwsgi_opt_set_str, &uwsgi.vassals_start_hook, 0},
 	{"vassals-stop-hook", required_argument, 0, "run the specified command after vassal's death", uwsgi_opt_set_str, &uwsgi.vassals_stop_hook, 0},
+	{"vassal-sos", required_argument, 0, "ask emperor for reinforcement when overloaded", uwsgi_opt_set_int, &uwsgi.vassal_sos, 0},
 	{"vassal-sos-backlog", required_argument, 0, "ask emperor for sos if backlog queue has more items than the value specified", uwsgi_opt_set_int, &uwsgi.vassal_sos_backlog, 0},
 	{"vassals-set", required_argument, 0, "automatically set the specified option (via --set) for every vassal", uwsgi_opt_add_string_list, &uwsgi.vassals_set, 0},
 	{"vassal-set", required_argument, 0, "automatically set the specified option (via --set) for every vassal", uwsgi_opt_add_string_list, &uwsgi.vassals_set, 0},
@@ -1583,6 +1584,17 @@ static void vacuum(void) {
 next:
 				uwsgi_sock = uwsgi_sock->next;
 			}
+			if (uwsgi.stats) {
+				// is a unix socket ?
+				if (!strchr(uwsgi.stats, ':') && uwsgi.stats[0] != '@') {
+					if (unlink(uwsgi.stats)) {
+                                                uwsgi_error("unlink()");
+                                        }
+                                        else {
+                                                uwsgi_log("VACUUM: unix socket %s (stats) removed.\n", uwsgi.stats);
+                                        }
+				}
+			}
 		}
 	}
 }
@@ -3786,7 +3798,8 @@ void uwsgi_opt_false(char *opt, char *value, void *key) {
 }
 
 void uwsgi_opt_set_immediate_gid(char *opt, char *value, void *none) {
-        gid_t gid = atoi(value);
+        gid_t gid = 0;
+	if (is_a_number(value)) gid = atoi(value);
 	if (gid == 0) {
 		struct group *ugroup = getgrnam(value);
                 if (ugroup)
@@ -3815,7 +3828,8 @@ void uwsgi_opt_set_immediate_gid(char *opt, char *value, void *none) {
 
 
 void uwsgi_opt_set_immediate_uid(char *opt, char *value, void *none) {
-	uid_t uid = atoi(value);
+	uid_t uid = 0;
+	if (is_a_number(value)) uid = atoi(value);
 	if (uid == 0) {
 		struct passwd *upasswd = getpwnam(value);
                 if (upasswd)
@@ -3862,7 +3876,8 @@ void uwsgi_opt_set_int(char *opt, char *value, void *key) {
 }
 
 void uwsgi_opt_uid(char *opt, char *value, void *key) {
-	uid_t uid = atoi(value);
+	uid_t uid = 0;
+	if (is_a_number(value)) uid = atoi(value);
 	if (!uid) {
 		struct passwd *p = getpwnam(value);
 		if (p) {
@@ -3880,7 +3895,8 @@ void uwsgi_opt_uid(char *opt, char *value, void *key) {
 }
 
 void uwsgi_opt_gid(char *opt, char *value, void *key) {
-        gid_t gid = atoi(value);
+        gid_t gid = 0;
+	if (is_a_number(value)) gid = atoi(value);
         if (!gid) {
                 struct group *g = getgrnam(value);
                 if (g) {
@@ -4181,15 +4197,13 @@ void uwsgi_opt_print(char *opt, char *value, void *str) {
 }
 
 void uwsgi_opt_set_uid(char *opt, char *value, void *none) {
-
-	uwsgi.uid = atoi(value);
+	if (is_a_number(value)) uwsgi.uid = atoi(value);
 	if (!uwsgi.uid)
 		uwsgi.uidname = value;
 }
 
 void uwsgi_opt_set_gid(char *opt, char *value, void *none) {
-
-	uwsgi.gid = atoi(value);
+	if (is_a_number(value)) uwsgi.gid = atoi(value);
 	if (!uwsgi.gid)
 		uwsgi.gidname = value;
 }

plugins/emperor_zeromq/uwsgiplugin.py

@@ -2,6 +2,6 @@
 NAME='emperor_zeromq'
 CFLAGS = []
 LDFLAGS = []
-LIBS = []
+LIBS = ['-lzmq']
 
 GCC_LIST = ['emperor_zeromq']

plugins/logfile/logfile.c

@@ -1,10 +1,49 @@
 #include <uwsgi.h>
 
+struct logfile_data {
+	char *logfile;
+	char *backupname;
+	uint64_t maxsize;
+};
+
 static ssize_t uwsgi_file_logger(struct uwsgi_logger *ul, char *message, size_t len) {
 
 	if (!ul->configured) {
 		if (ul->arg) {
-			ul->fd = open(ul->arg, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);
+			int is_keyval = 0;
+			char *backupname = NULL;
+			char *maxsize = NULL;
+			char *logfile = NULL;
+
+			if (strchr(ul->arg, '=')) {
+				if (uwsgi_kvlist_parse(ul->arg, strlen(ul->arg), ',', '=',
+					"logfile", &logfile, "backupname", &backupname, "maxsize", &maxsize, NULL)) {
+					uwsgi_log("[uwsgi-logfile] invalid keyval syntax\n");
+					exit(1);
+				}
+				is_keyval = 1;
+			}
+			if (is_keyval) {
+				if (!logfile) {
+					uwsgi_log("[uwsgi-logfile] missing logfile key\n");
+					return 0;
+				}
+
+				if (maxsize) {
+					struct logfile_data *data = uwsgi_malloc(sizeof(struct logfile_data));
+					data->logfile = logfile;
+					data->backupname = backupname;
+					data->maxsize = (uint64_t)strtoull(maxsize, NULL, 10);
+					ul->data = data;
+
+					free(maxsize);
+					maxsize = NULL;
+				}
+			} else {
+				logfile = ul->arg;
+			}
+
+			ul->fd = open(logfile, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);
 			if (ul->fd >= 0) {
 				ul->configured = 1;
 			}	
@@ -12,10 +51,21 @@ static ssize_t uwsgi_file_logger(struct uwsgi_logger *ul, char *message, size_t
 	}
 
 	if (ul->fd >= 0) {
-		return write(ul->fd, message, len);
-	}
-	return 0;
+		ssize_t written = write(ul->fd, message, len);
 
+		if (ul->data) {
+			struct logfile_data *data = ul->data;
+			off_t logsize = lseek(ul->fd, 0, SEEK_CUR);
+
+			if (data->maxsize > 0 && (uint64_t) logsize > data->maxsize) {
+				uwsgi_log_do_rotate(data->logfile, data->backupname, logsize, ul->fd);
+			}
+		}
+
+		return written;
+	}
+
+	return 0;
 }
 
 static ssize_t uwsgi_fd_logger(struct uwsgi_logger *ul, char *message, size_t len) {

plugins/mono/uwsgiplugin.py

@@ -6,6 +6,9 @@ LDFLAGS = []
 LIBS = os.popen('pkg-config --libs mono-2').read().rstrip().split() 
 GCC_LIST = ['mono_plugin']
 
+if os.uname()[0] == 'Darwin':
+	LIBS.append('-framework Foundation')
+
 def post_build(config):
     if os.system("sn -k plugins/mono/uwsgi.key") != 0:
         os._exit(1)

plugins/php/php_plugin.c

@@ -254,8 +254,9 @@ PHP_FUNCTION(uwsgi_cache_exists) {
         char *key = NULL;
         int keylen = 0;
         char *cache = NULL;
+        int cachelen = 0;
 
-        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache) == FAILURE) {
+        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 
@@ -269,8 +270,9 @@ PHP_FUNCTION(uwsgi_cache_exists) {
 PHP_FUNCTION(uwsgi_cache_clear) {
 
         char *cache = NULL;
+        int cachelen = 0;
 
-        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &cache) == FAILURE) {
+        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 
@@ -287,8 +289,9 @@ PHP_FUNCTION(uwsgi_cache_del) {
 	char *key = NULL;
         int keylen = 0;
 	char *cache = NULL;
+	int cachelen = 0;
 
-        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache) == FAILURE) {
+        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 
@@ -304,12 +307,13 @@ PHP_FUNCTION(uwsgi_cache_get) {
 	char *key = NULL;
 	int keylen = 0;
 	char *cache = NULL;
+	int cachelen = 0;
 	uint64_t valsize;
 
 	if (!uwsgi.caches)
 		RETURN_NULL();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &key, &keylen, &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 
@@ -329,11 +333,12 @@ PHP_FUNCTION(uwsgi_cache_set) {
 	int vallen;
 	uint64_t expires = 0;
 	char *cache = NULL;
+	int cachelen = 0;
 
 	if (!uwsgi.caches)
 		RETURN_NULL();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", &key, &keylen, &value, &vallen, &expires, &cache) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", &key, &keylen, &value, &vallen, &expires, &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 
@@ -351,11 +356,12 @@ PHP_FUNCTION(uwsgi_cache_update) {
         int vallen;
         uint64_t expires = 0;
         char *cache = NULL;
+        int cachelen = 0;
 
         if (!uwsgi.caches)
                 RETURN_NULL();
 
-        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", &key, &keylen, &value, &vallen, &expires, &cache) == FAILURE) {
+        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", &key, &keylen, &value, &vallen, &expires, &cache, &cachelen) == FAILURE) {
                 RETURN_NULL();
         }
 

plugins/psgi/uwsgi_plmodule.c

@@ -946,7 +946,7 @@ XS(XS_spool) {
 		}
         }
 
-	char *filename = uwsgi_spool_request(current_wsgi_req(), ub->buf, ub->pos, body, body_len);
+	char *filename = uwsgi_spool_request(NULL, ub->buf, ub->pos, body, body_len);
 	uwsgi_buffer_destroy(ub);
 	if (filename) {
 		ST(0) = newSVpv(filename, strlen(filename));

plugins/python/pyloader.c

@@ -325,12 +325,19 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	if (uwsgi.threads > 1 && id) {
 		// if we have multiple threads we need to initialize a PyThreadState for each one
 		for(i=0;i<uwsgi.threads;i++) {
-			//uwsgi_log("%p\n", uwsgi.core[i]->ts[id]);
 			uwsgi.workers[uwsgi.mywid].cores[i].ts[id] = PyThreadState_New( ((PyThreadState *)wi->interpreter)->interp);
+			//uwsgi_log("%p\n", uwsgi.workers[uwsgi.mywid].cores[i].ts[id]);
 			if (!uwsgi.workers[uwsgi.mywid].cores[i].ts[id]) {
 				uwsgi_log("unable to allocate new PyThreadState structure for app %s", wi->mountpoint);
 				goto doh;
 			}
+			// cow ?
+			if (uwsgi.mywid == 0) {
+				int j;
+				for(j=1;j<=uwsgi.numproc;j++) {
+					uwsgi.workers[j].cores[i].ts[id] = uwsgi.workers[0].cores[i].ts[id];
+				}
+			}
 		}
 		PyThreadState_Swap((PyThreadState *) pthread_getspecific(up.upt_save_key) );
 	}

plugins/python/python_plugin.c

@@ -920,12 +920,16 @@ int uwsgi_python_mount_app(char *mountpoint, char *app) {
 	if (strchr(app, ':') || uwsgi_endswith(app, ".py") || uwsgi_endswith(app, ".wsgi")) {
 		uwsgi.wsgi_req->appid = mountpoint;
 		uwsgi.wsgi_req->appid_len = strlen(mountpoint);
+		// lazy ?
+        	if (uwsgi.mywid > 0) UWSGI_GET_GIL
 		if (uwsgi.single_interpreter) {
 			id = init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 		}
 		else {
 			id = init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
 		}
+		// lazy ?
+        	if (uwsgi.mywid > 0) UWSGI_RELEASE_GIL
 		return id;
 	}
 	return -1;

plugins/python/uwsgi_pymodule.c

@@ -382,6 +382,11 @@ PyObject *py_uwsgi_rpc(PyObject * self, PyObject * args) {
 	if (PyString_Check(py_node)) {
 		node = PyString_AsString(py_node);
 	}
+#ifdef PYTHREE
+        else if (PyUnicode_Check(py_node)) {
+                node = PyBytes_AsString(PyUnicode_AsLatin1String(py_node));
+	}
+#endif
 
 	py_func = PyTuple_GetItem(args, 1);
 
@@ -1855,7 +1860,6 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 	PyObject *spool_dict, *spool_vars;
 	PyObject *zero, *key, *val;
 	uint16_t keysize, valsize;
-	struct wsgi_request *wsgi_req = py_current_wsgi_req();
 	char *body = NULL;
 	size_t body_len= 0;
 
@@ -1956,7 +1960,8 @@ PyObject *py_uwsgi_send_spool(PyObject * self, PyObject * args, PyObject *kw) {
 
 	UWSGI_RELEASE_GIL
 
-	char *filename = uwsgi_spool_request(wsgi_req, ub->buf, ub->pos, body, body_len);
+	// current_wsgi_req can be NULL, in such a case a non-thread-safe counter will be used
+	char *filename = uwsgi_spool_request(NULL, ub->buf, ub->pos, body, body_len);
 	uwsgi_buffer_destroy(ub);
 
 	UWSGI_GET_GIL
@@ -2240,7 +2245,8 @@ PyObject *py_uwsgi_stop(PyObject * self, PyObject * args) {
 }
 
 PyObject *py_uwsgi_request_id(PyObject * self, PyObject * args) {
-	return PyLong_FromUnsignedLongLong(uwsgi.workers[uwsgi.mywid].requests);
+	struct wsgi_request *wsgi_req = py_current_wsgi_req();
+	return PyLong_FromUnsignedLongLong(uwsgi.workers[uwsgi.mywid].cores[wsgi_req->async_id].requests);
 }
 
 PyObject *py_uwsgi_worker_id(PyObject * self, PyObject * args) {

plugins/rack/rack_api.c

@@ -969,7 +969,6 @@ static int rack_uwsgi_build_spool(VALUE rbkey, VALUE rbval, VALUE argv) {
 
 static VALUE rack_uwsgi_send_spool(VALUE *class, VALUE args) {
 
-        struct wsgi_request *wsgi_req = current_wsgi_req();
         char *body = NULL;
         size_t body_len= 0;
 
@@ -991,7 +990,7 @@ static VALUE rack_uwsgi_send_spool(VALUE *class, VALUE args) {
 
 	rb_hash_foreach(args, rack_uwsgi_build_spool, (VALUE) ub); 
 
-        char *filename = uwsgi_spool_request(wsgi_req, ub->buf, ub->pos, body, body_len);
+        char *filename = uwsgi_spool_request(NULL, ub->buf, ub->pos, body, body_len);
 
 	uwsgi_buffer_destroy(ub);
 

plugins/rados/rados.c

@@ -147,7 +147,7 @@ static int uwsgi_rados_put(struct wsgi_request *wsgi_req, rados_ioctx_t ctx, cha
                 char *body =  uwsgi_request_body_read(wsgi_req, UMIN(remains, 32768) , &body_len);
                 if (!body || body == uwsgi.empty) goto error;
 		if (uwsgi.async <= 1) {
-			if (rados_write(ctx, key, body, body_len, off) <= 0) {
+			if (rados_write(ctx, key, body, body_len, off) < 0) {
 				return -1;
 			}
 		}

plugins/rpc/rpc_plugin.c

@@ -387,6 +387,7 @@ end:
 }
 
 static int uwsgi_routing_func_rpc_raw(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+	char *response = NULL;
         int ret = -1;
         // this is the list of args
         char *argv[UMAX8];
@@ -418,7 +419,7 @@ static int uwsgi_routing_func_rpc_raw(struct wsgi_request *wsgi_req, struct uwsg
                 remote = at+1;
         }
         uint64_t size;
-        char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
+        response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
         free(func);
         if (!response) goto end;
 
@@ -426,12 +427,13 @@ static int uwsgi_routing_func_rpc_raw(struct wsgi_request *wsgi_req, struct uwsg
 	if (size == 0) goto end;
 
 	ret = uwsgi_blob_to_response(wsgi_req, response, size);
-        free(response);
 	if (ret == 0) {
 		ret = UWSGI_ROUTE_BREAK;
 	}
 
 end:
+	free(response);
+
         for(i=0;i<ur->custom;i++) {
                 if (ubs[i] != NULL) {
                         uwsgi_buffer_destroy(ubs[i]);
@@ -441,6 +443,7 @@ end:
 }
 
 static int uwsgi_routing_func_rpc_var(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        char *response = NULL;
         int ret = -1;
         // this is the list of args
         char *argv[UMAX8];
@@ -472,7 +475,7 @@ static int uwsgi_routing_func_rpc_var(struct wsgi_request *wsgi_req, struct uwsg
                 remote = at+1;
         }
         uint64_t size;
-        char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
+        response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
         free(func);
         if (!response) goto end;
 
@@ -483,9 +486,9 @@ static int uwsgi_routing_func_rpc_var(struct wsgi_request *wsgi_req, struct uwsg
 		free(response);
 		goto end;
 	}
-	free(response);
 	ret = UWSGI_ROUTE_NEXT;
 end:
+	free(response);
         for(i=0;i<ur->custom;i++) {
                 if (ubs[i] != NULL) {
                         uwsgi_buffer_destroy(ubs[i]);

plugins/spooler/spooler_plugin.c

@@ -23,7 +23,7 @@ int uwsgi_request_spooler(struct wsgi_request *wsgi_req) {
                 return -1;
         }
 
-        char *filename = uwsgi_spool_request(wsgi_req, wsgi_req->buffer, wsgi_req->uh->pktsize, NULL, 0);
+        char *filename = uwsgi_spool_request(NULL, wsgi_req->buffer, wsgi_req->uh->pktsize, NULL, 0);
         uh.modifier1 = 255;
         uh.pktsize = 0;
         if (filename) {

plugins/stats_pusher_statsd/plugin.c

@@ -92,7 +92,7 @@ static void stats_pusher_statsd(struct uwsgi_stats_pusher_instance *uspi, time_t
 			statsd_send_metric(ub, uspi, um->name, um->name_len, *um->value, "|g");
 		}
 		else {
-			statsd_send_metric(ub, uspi, um->name, um->name_len, *um->value, "|m");
+			statsd_send_metric(ub, uspi, um->name, um->name_len, *um->value, "|c");
 		}
 		uwsgi_rwunlock(uwsgi.metrics_lock);
 		if (um->reset_after_push){

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        = '2014-07-01'
+  s.date        = '2014-09-05'
   s.summary     = "uWSGI"
   s.description = "The uWSGI server for Ruby/Rack"
   s.authors     = ["Unbit"]

uwsgi.h

@@ -6,6 +6,8 @@
 extern "C" {
 #endif
 
+#define UWSGI_PLUGIN_API	1
+
 #define UMAX16	65536
 #define UMAX8	256
 
@@ -832,6 +834,8 @@ struct uwsgi_cache {
 	int purge_lru;
 	uint64_t lru_head;
 	uint64_t lru_tail;
+
+	int store_delete;
 };
 
 struct uwsgi_option {
@@ -998,6 +1002,7 @@ struct uwsgi_protocol {
 };
 
 struct uwsgi_server;
+struct uwsgi_instance;
 
 struct uwsgi_plugin {
 
@@ -1056,6 +1061,9 @@ struct uwsgi_plugin {
         struct uwsgi_buffer* (*exception_msg)(struct wsgi_request *);
         struct uwsgi_buffer* (*exception_repr)(struct wsgi_request *);
         void (*exception_log)(struct wsgi_request *);
+
+	void (*vassal)(struct uwsgi_instance *);
+	void (*vassal_before_exec)(struct uwsgi_instance *);
 };
 
 #ifdef UWSGI_PCRE
@@ -2725,6 +2733,9 @@ struct uwsgi_server {
 	int stats_no_cores;
 	int stats_no_metrics;
 
+	// uWSGI 2.0.7
+	int vassal_sos;
+
 };
 
 struct uwsgi_rpc {
@@ -4590,6 +4601,7 @@ void uwsgi_master_fifo_prepare();
 int uwsgi_master_fifo();
 int uwsgi_master_fifo_manage(int);
 
+void uwsgi_log_do_rotate(char *, char *, off_t, int);
 void uwsgi_log_rotate();
 void uwsgi_log_reopen();
 void uwsgi_reload_workers();
@@ -4788,6 +4800,7 @@ mode_t uwsgi_mode_t(char *, int *);
 
 int uwsgi_notify_socket_manage(int);
 int uwsgi_notify_msg(char *, char *, size_t);
+void vassal_sos();
 
 #ifdef __cplusplus
 }

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '2.0.6'
+uwsgi_version = '2.0.7'
 
 import os
 import re
@@ -53,6 +53,11 @@ if CPUCOUNT < 1:
         except:
             CPUCOUNT = 1
 
+
+# force single cpu in cygwin mode
+if uwsgi_os.startswith('CYGWIN'):
+    CPUCOUNT=1
+
 binary_list = []
 
 started_at = time.time()