自学教程：C++ uwsgi_log函数代码示例

PyObject *py_uwsgi_gevent_main(PyObject * self, PyObject * args) {	struct wsgi_request *wsgi_req = find_first_available_wsgi_req();	if (wsgi_req == NULL) {		uwsgi_log("async queue is full !!!/n");		goto clear;	}	// fill wsgi_request structure	wsgi_req_setup(wsgi_req, wsgi_req->async_id, uwsgi.sockets );	// mark core as used	uwsgi.core[wsgi_req->async_id]->in_request = 1;	gettimeofday(&wsgi_req->start_of_request, NULL);	// enter harakiri mode        if (uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {                set_harakiri(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI]);        }	// accept the connection	if (wsgi_req_simple_accept(wsgi_req, uwsgi.sockets->fd)) {		free_req_queue;		goto clear;	}	// hack to easily pass wsgi_req pointer to the greenlet	PyTuple_SetItem(ugevent.greenlet_args, 1, PyLong_FromLong((long)wsgi_req));	// spawn the request greenlet	PyObject *new_gl = python_call(ugevent.spawn, ugevent.greenlet_args, 0, NULL);	Py_DECREF(new_gl);clear:	Py_INCREF(Py_None);	return Py_None;}

static struct uwsgi_lock_item *uwsgi_register_lock(char *id, int rw) {	struct uwsgi_lock_item *uli = uwsgi.registered_locks;	if (!uli) {		uwsgi.registered_locks = uwsgi_malloc_shared(sizeof(struct uwsgi_lock_item));		uwsgi.registered_locks->id = id;		uwsgi.registered_locks->pid = 0;		if (rw) {			uwsgi.registered_locks->lock_ptr = uwsgi_malloc_shared(uwsgi.rwlock_size);		}		else {			uwsgi.registered_locks->lock_ptr = uwsgi_malloc_shared(uwsgi.lock_size);		}		uwsgi.registered_locks->rw = rw;		uwsgi.registered_locks->next = NULL;		return uwsgi.registered_locks;	}	while(uli) {		if (!uli->next) {			uli->next = uwsgi_malloc_shared(sizeof(struct uwsgi_lock_item));			if (rw) {				uli->next->lock_ptr = uwsgi_malloc_shared(uwsgi.rwlock_size);			}			else {				uli->next->lock_ptr = uwsgi_malloc_shared(uwsgi.lock_size);			}			uli->next->id = id;			uli->next->pid = 0;			uli->next->rw = rw;			uli->next->next = NULL;			return uli->next;		}		uli = uli->next;	}	uwsgi_log("*** DANGER: unable to allocate lock %s ***/n", id);	exit(1);}

int uwsgi_master_check_mercy() {	int i, waitpid_status;	if (uwsgi.master_mercy) {		if (uwsgi.master_mercy < uwsgi_now()) {			for (i = 1; i <= uwsgi.numproc; i++) {				if (uwsgi.workers[i].pid > 0) {					if (uwsgi.lazy && uwsgi.workers[i].destroy == 0)						continue;					uwsgi_log("worker %d (pid: %d) is taking too much time to die...NO MERCY !!!/n", i, uwsgi.workers[i].pid);					if (!kill(uwsgi.workers[i].pid, SIGKILL)) {						if (waitpid(uwsgi.workers[i].pid, &waitpid_status, 0) < 0) {							uwsgi_error("waitpid()");						}						uwsgi.workers[i].pid = 0;						if (uwsgi.to_hell) {							uwsgi.ready_to_die++;						}						else if (uwsgi.to_heaven) {							uwsgi.ready_to_reload++;						}						else if (uwsgi.to_outworld) {							uwsgi.lazy_respawned++;							if (uwsgi_respawn_worker(i))								return -1;						}					}					else {						uwsgi_error("kill()");					}				}			}			uwsgi.master_mercy = 0;		}	}	return 0;}

void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char *config, time_t ts, uid_t uid, gid_t gid, char *socket_name) {	if (!uwsgi_emperor_is_valid(name))		return;	struct uwsgi_instance *ui_current = emperor_get(name);	if (ui_current) {		// check if uid or gid are changed, in such case, stop the instance		if (uwsgi.emperor_tyrant) {			if (uid != ui_current->uid || gid != ui_current->gid) {				uwsgi_log("[emperor-tyrant] !!! permissions of vassal %s changed. stopping the instance... !!!/n", name);				emperor_stop(ui_current);				return;			}		}		// check if mtime is changed and the uWSGI instance must be reloaded		if (ts > ui_current->last_mod) {			// make a new config (free the old one) if needed			if (config) {				if (ui_current->config)					free(ui_current->config);				ui_current->config = uwsgi_str(config);				ui_current->config_len = strlen(ui_current->config);			}			// reload the instance			emperor_respawn(ui_current, ts);		}	}	else {		// make a copy of the config as it will be freed		char *new_config = NULL;		size_t new_config_len = 0;		if (config) {			new_config = uwsgi_str(config);			new_config_len = strlen(new_config);		}		emperor_add(ues, name, ts, new_config, new_config_len, uid, gid, socket_name);	}}

void uwsgi_opt_add_route(char *opt, char *value, void *foobar) {	struct uwsgi_route *old_ur = NULL,*ur = uwsgi.routes;	uint64_t pos = 0;	while(ur) {		old_ur = ur;		ur = ur->next;		pos++;	}	ur = uwsgi_calloc(sizeof(struct uwsgi_route));	if (old_ur) {		old_ur->next = ur;	}	else {		uwsgi.routes = ur;	}	ur->pos = pos;	// is it a label ?	if (foobar == NULL) {		ur->label = value;		ur->label_len = strlen(value);		return;	}	char *route = uwsgi_str(value);	char *space = strchr(route, ' ');	if (!space) {		uwsgi_log("invalid route syntax/n");		exit(1);	}	*space = 0;	if (!strcmp(foobar, "http_host")) {		ur->subject = offsetof(struct wsgi_request, host);		ur->subject_len = offsetof(struct wsgi_request, host_len);	}

void uwsgi_daemons_spawn_all() {	struct uwsgi_daemon *ud = uwsgi.daemons;	while (ud) {		if (!ud->registered) {			if (ud->pidfile) {				int checked_pid = uwsgi_check_pidfile(ud->pidfile);				if (checked_pid <= 0) {					uwsgi_spawn_daemon(ud);				}				else {					ud->pid = checked_pid;					uwsgi_log("[uwsgi-daemons] found valid/active pidfile for /"%s/" (pid: %d)/n", ud->command, (int) ud->pid);				}			}			else {				uwsgi_spawn_daemon(ud);			}			ud->registered = 1;		}		ud = ud->next;	}}

int uwsgi_proto_scgi_parser(struct wsgi_request *wsgi_req) {	// first round ? (wsgi_req->proto_parser_buf is freed at the end of the request)        if (!wsgi_req->proto_parser_buf) {                wsgi_req->proto_parser_buf = uwsgi_malloc(uwsgi.buffer_size);        }	if (uwsgi.buffer_size - wsgi_req->proto_parser_pos == 0) {                uwsgi_log("invalid SCGI request size (max %u)...skip/n", uwsgi.buffer_size);                return -1;        }	char *ptr = wsgi_req->proto_parser_buf;	ssize_t len = read(wsgi_req->fd, ptr + wsgi_req->proto_parser_pos, uwsgi.buffer_size - wsgi_req->proto_parser_pos);	if (len > 0) {		wsgi_req->proto_parser_pos += len;		int ret = scgi_parse(wsgi_req);		if (ret > 0) {			wsgi_req->uh->modifier1 = uwsgi.scgi_modifier1;                        wsgi_req->uh->modifier2 = uwsgi.scgi_modifier2;			return UWSGI_OK;		}		if (ret == 0) return UWSGI_AGAIN;		return -1;	}	if (len < 0) {		if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS) {			return UWSGI_AGAIN;		}		uwsgi_error("uwsgi_proto_scgi_parser()");			return -1;	}	// 0 len	if (wsgi_req->proto_parser_pos > 0) {		uwsgi_error("uwsgi_proto_scgi_parser()");		}	return -1;}

int uwsgi_hooks_run_and_return(struct uwsgi_string_list *l, char *phase, char *context, int fatal) {	int final_ret = 0;	struct uwsgi_string_list *usl = NULL;	if (context) {		if (setenv("UWSGI_HOOK_CONTEXT", context, 1)) {			uwsgi_error("uwsgi_hooks_run_and_return()/setenv()");			return -1;		}	}        uwsgi_foreach(usl, l) {                char *colon = strchr(usl->value, ':');                if (!colon) {                        uwsgi_log("invalid hook syntax, must be hook:args/n");                        exit(1);                }                *colon = 0;                int private = 0;                char *action = usl->value;                // private hook ?                if (action[0] == '!') {                        action++;                        private = 1;

// create a new coroSV * coroae_coro_new(CV *block) {	SV *newobj = NULL;	dSP;        ENTER;        SAVETMPS;        PUSHMARK(SP);        XPUSHs(sv_2mortal(newSVpv( "Coro", 4)));        XPUSHs(newRV_inc((SV *)block));        PUTBACK;        call_method("new", G_SCALAR);        SPAGAIN;        if(SvTRUE(ERRSV)) {                uwsgi_log("[uwsgi-perl error] %s", SvPV_nolen(ERRSV));        }        else {                newobj = SvREFCNT_inc(POPs);        }	PUTBACK;        FREETMPS;        LEAVE;	return newobj;}

int event_queue_add_file_monitor(int eq, char *filename, int *id) {	struct kevent kev;	int fd = open(filename, O_RDONLY);	if (fd < 0) {		uwsgi_error_open(filename);		return -1;	}	        EV_SET(&kev, fd, EVFILT_VNODE, EV_ADD|EV_CLEAR, NOTE_WRITE|NOTE_DELETE|NOTE_EXTEND|NOTE_ATTRIB|NOTE_RENAME|NOTE_REVOKE, 0, 0);        if (kevent(eq, &kev, 1, NULL, 0, NULL) < 0) {                uwsgi_error("kevent()");                return -1;        }	*id = fd;	uwsgi_log("added new file to monitor %s/n", filename);		return fd;}

SSL_SESSION *uwsgi_ssl_session_get_cb(SSL *ssl, unsigned char *key, int keylen, int *copy) {        uint64_t valsize = 0;        *copy = 0;        uwsgi_rlock(uwsgi.ssl_sessions_cache->lock);        char *value = uwsgi_cache_get2(uwsgi.ssl_sessions_cache, (char *)key, keylen, &valsize);        if (!value) {                uwsgi_rwunlock(uwsgi.ssl_sessions_cache->lock);                if (uwsgi.ssl_verbose) {                        uwsgi_log("[uwsgi-ssl] cache miss/n");                }                return NULL;        }#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)        SSL_SESSION *sess = d2i_SSL_SESSION(NULL, (const unsigned char **)&value, valsize);#else        SSL_SESSION *sess = d2i_SSL_SESSION(NULL, (unsigned char **)&value, valsize);#endif        uwsgi_rwunlock(uwsgi.ssl_sessions_cache->lock);        return sess;}

struct uwsgi_gateway *register_gateway(char *name, void (*loop)(int, void *), void *data) {        struct uwsgi_gateway *ug;        int num=1,i;        if (ushared->gateways_cnt >= MAX_GATEWAYS) {                uwsgi_log("you can register max %d gateways/n", MAX_GATEWAYS);                return NULL;        }        for(i=0;i<ushared->gateways_cnt;i++) {                if (!strcmp(name, ushared->gateways[i].name)) {                        num++;                }        }	char *fullname = uwsgi_concat3(name, " ", uwsgi_num2str(num));        ug = &ushared->gateways[ushared->gateways_cnt];        ug->pid = 0;        ug->name = name;        ug->loop = loop;        ug->num = num;	ug->fullname = fullname;	ug->data = data;	if (socketpair(AF_UNIX, SOCK_DGRAM, 0, ug->internal_subscription_pipe)) {		uwsgi_error("socketpair()");	}	if (!uwsgi.master_process)		gateway_respawn(ushared->gateways_cnt);        ushared->gateways_cnt++;        return ug;}

void uwsgi_python_init_thread(int core_id) {	// set a new ThreadState for each thread	PyThreadState *pts;	pts = PyThreadState_New(up.main_thread->interp);	pthread_setspecific(up.upt_save_key, (void *) pts);	pthread_setspecific(up.upt_gil_key, (void *) pts);#ifdef UWSGI_DEBUG	uwsgi_log("python ThreadState %d = %p/n", core_id, pts);#endif	UWSGI_GET_GIL;	// call threading.currentThread (taken from mod_wsgi, but removes DECREFs as thread in uWSGI are fixed)	PyObject *threading_module = PyImport_ImportModule("threading");        if (threading_module) {        	PyObject *threading_module_dict = PyModule_GetDict(threading_module);                if (threading_module_dict) {#ifdef PYTHREE			PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "current_thread");#else			PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "currentThread");#endif                        if (threading_current) {                                PyObject *current_thread = PyEval_CallObject(threading_current, (PyObject *)NULL);                                if (!current_thread) {					// ignore the error                                        PyErr_Clear();                                }				else {					PyObject_SetAttrString(current_thread, "name", PyString_FromFormat("uWSGIWorker%dCore%d", uwsgi.mywid, core_id));					Py_INCREF(current_thread);				}                        }                }        }	UWSGI_RELEASE_GIL;	}

void carbon_post_init() {	int i;	struct uwsgi_string_list *usl = u_carbon.servers;	if (!uwsgi.sockets) return;	if (!u_carbon.servers) return;	while(usl) {		uwsgi_log("added carbon server %s/n", usl->value);		usl = usl->next;	}	if (u_carbon.freq < 1) u_carbon.freq = 60;	if (u_carbon.timeout < 1) u_carbon.timeout = 3;	if (!u_carbon.id) { 		u_carbon.id = uwsgi_str(uwsgi.sockets->name);		for(i=0;i<(int)strlen(u_carbon.id);i++) {			if (u_carbon.id[i] == '.') u_carbon.id[i] = '_';		}	}}

// create a new coroSV * coroae_coro_new(CV *block) {	SV *newobj = NULL;	dSP;        ENTER;        SAVETMPS;        PUSHMARK(SP);        mXPUSHs(newSVpvs("Coro"));        mXPUSHs(newRV_noinc((SV *)block));        PUTBACK;        call_method("new", G_SCALAR|G_EVAL);        SPAGAIN;        if(SvTRUE(ERRSV)) {                uwsgi_log("[uwsgi-perl error] %s", SvPV_nolen(ERRSV));                (void)POPs; // we must pop undef from the stack in G_SCALAR context        }        else {                newobj = SvREFCNT_inc(POPs);        }	PUTBACK;        FREETMPS;        LEAVE;	return newobj;}

PyObject *py_uwsgi_gevent_int(PyObject *self, PyObject *args) {        uwsgi_log("Brutally killing worker %d (pid: %d).../n", uwsgi.mywid, uwsgi.mypid);        uwsgi.workers[uwsgi.mywid].manage_next_request = 0;        uwsgi_log_verbose("stopping gevent signals watchers for worker %d (pid: %d).../n", uwsgi.mywid, uwsgi.mypid);        PyObject_CallMethod(ugevent.my_signal_watcher, "stop", NULL);        PyObject_CallMethod(ugevent.signal_watcher, "stop", NULL);        uwsgi_log_verbose("stopping gevent sockets watchers for worker %d (pid: %d).../n", uwsgi.mywid, uwsgi.mypid);        int i,count = uwsgi_count_sockets(uwsgi.sockets);        for(i=0;i<count;i++) {                PyObject_CallMethod(ugevent.watchers[i], "stop", NULL);        }        uwsgi_log_verbose("main gevent watchers stopped for worker %d (pid: %d).../n", uwsgi.mywid, uwsgi.mypid);        if (!ugevent.wait_for_hub) {                PyObject_CallMethod(ugevent.ctrl_gl, "kill", NULL);        }        Py_INCREF(Py_None);        return Py_None;}

int uwsgi_add_timer(uint8_t sig, int secs) {	uwsgi_lock(uwsgi.timer_table_lock);	if (ushared->timers_cnt < 64) {		// fill the timer table, the master will use it to add items to the event queue		ushared->timers[ushared->timers_cnt].value = secs;		ushared->timers[ushared->timers_cnt].registered = 0;		ushared->timers[ushared->timers_cnt].sig = sig;		ushared->timers_cnt++;	}	else {		uwsgi_log("you can register max 64 timers !!!/n");		uwsgi_unlock(uwsgi.timer_table_lock);		return -1;	}	uwsgi_unlock(uwsgi.timer_table_lock);	return 0;}

static int uwsgi_hook_append(char *arg) {        char *space = strchr(arg, ' ');        if (!space) {                uwsgi_log("invalid hook append syntax, must be: <file> <string>/n");                return -1;        }        *space = 0;        int fd = open(arg, O_WRONLY|O_CREAT|O_APPEND, 0666);        if (fd < 0) {                uwsgi_error_open(arg);                *space = ' ';                return -1;        }        *space = ' ';        size_t l = strlen(space+1);        if (write(fd, space+1, l) != (ssize_t) l) {                uwsgi_error("uwsgi_hook_append()/write()");                close(fd);                return -1;        }        close(fd);        return 0;}

void uwsgi_stats_pusher_setup() {	struct uwsgi_string_list *usl = uwsgi.requested_stats_pushers;	while (usl) {		char *ssp = uwsgi_str(usl->value);		struct uwsgi_stats_pusher *pusher = NULL;		char *colon = strchr(ssp, ':');		if (colon) {			*colon = 0;		}		pusher = uwsgi_stats_pusher_get(ssp);		if (!pusher) {			uwsgi_log("unable to find /"%s/" stats_pusher/n", ssp);			exit(1);		}		char *arg = NULL;		if (colon) {			arg = colon + 1;			*colon = ':';		}		uwsgi_stats_pusher_add(pusher, arg);		usl = usl->next;	}}

static SV *coroae_add_watcher(int fd, CV *cb) {        SV *newobj;        dSP;        ENTER;        SAVETMPS;        PUSHMARK(SP);        mXPUSHs(newSVpvs("AnyEvent"));        mXPUSHs(newSVpvs("fh"));        mXPUSHs(newSViv(fd));        mXPUSHs(newSVpvs("poll"));        mXPUSHs(newSVpvs("r"));        mXPUSHs(newSVpvs("cb"));        mXPUSHs(newRV_noinc((SV *)cb));        PUTBACK;        call_method( "io", G_SCALAR|G_EVAL);        SPAGAIN;	if(SvTRUE(ERRSV)) {		// no need to continue...                uwsgi_log("[uwsgi-perl error] %s", SvPV_nolen(ERRSV));		exit(1);        }	else {        	newobj = SvREFCNT_inc(POPs);	}        PUTBACK;        FREETMPS;        LEAVE;        return newobj;}

void uwsgi_python_harakiri(int wid) {	if (up.tracebacker) {        	char buf[8192];		char *address = uwsgi_concat2(up.tracebacker, uwsgi_num2str(wid));        	int fd = uwsgi_connect(address, -1, 0);        	for (;;) {                	int ret = uwsgi_waitfd(fd, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);                	if (ret <= 0) {				break;                	}                	ssize_t len = read(fd, buf, 8192);                	if (len <= 0) {				break;                	}                	uwsgi_log("%.*s", (int) len, buf);        	}		free(address);	}}

static int coroae_wait_fd_write(int fd, int timeout) {	int ret = 0;        dSP;        ENTER;        SAVETMPS;        PUSHMARK(SP);        XPUSHs(sv_2mortal(newSViv(fd)));        XPUSHs(sv_2mortal(newSViv(timeout)));        PUTBACK;        call_pv("Coro::AnyEvent::writable", G_SCALAR);        SPAGAIN;        if(SvTRUE(ERRSV)) {                uwsgi_log("[uwsgi-perl error] %s", SvPV_nolen(ERRSV));        }	else {		if (SvTRUE(POPs)) {			ret = 1;		}	}        FREETMPS;        LEAVE;	return ret;}

// this function is called when a dumb daemon dies and we want to respawn itint uwsgi_daemon_check_pid_reload(pid_t diedpid) {	struct uwsgi_daemon *ud = uwsgi.daemons;	while (ud) {#ifdef UWSGI_SSL		if (ud->pid == diedpid && ud->legion && !uwsgi_legion_i_am_the_lord(ud->legion)) {			// part of legion but not lord, don't respawn			ud->pid = -1;			uwsgi_log("uwsgi-daemons] legion /"%s/" daemon /"%s/" (pid: %d) annihilated/n", ud->legion, ud->command, (int) diedpid);			ud = ud->next;			continue;		}#endif		if (ud->pid == diedpid && !ud->pidfile) {			if (ud->control) {				gracefully_kill_them_all(0);				return 0;			}			uwsgi_spawn_daemon(ud);			return 1;		}		ud = ud->next;	}	return 0;}

int uwsgi_go_request(struct wsgi_request *wsgi_req) {	/* Standard GO request */        if (!wsgi_req->uh.pktsize) {                uwsgi_log("Invalid GO request. skip./n");                return -1;        }        if (uwsgi_parse_vars(wsgi_req)) {                return -1;        }	wsgi_req->async_environ = uwsgi_go_helper_env_new_c(wsgi_req);	int i;	for(i=0;i<wsgi_req->var_cnt;i++) {        	uwsgi_go_helper_env_add_c(wsgi_req->async_environ, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, 					wsgi_req->hvec[i+1].iov_base, wsgi_req->hvec[i+1].iov_len);		i++;	}	uwsgi_go_helper_request_c(wsgi_req->async_environ, wsgi_req);	return UWSGI_OK;}

void init_uwsgi_embedded_module() {	PyObject *new_uwsgi_module, *zero;	int i;	PyType_Ready(&uwsgi_InputType);	/* initialize for stats */	up.workers_tuple = PyTuple_New(uwsgi.numproc);	for (i = 0; i < uwsgi.numproc; i++) {		zero = PyDict_New();		Py_INCREF(zero);		PyTuple_SetItem(up.workers_tuple, i, zero);	}#ifdef PYTHREE	PyImport_AppendInittab("uwsgi", init_uwsgi3);	new_uwsgi_module = PyImport_AddModule("uwsgi");#else	new_uwsgi_module = Py_InitModule3("uwsgi", NULL, uwsgi_py_doc);#endif	if (new_uwsgi_module == NULL) {		uwsgi_log("could not initialize the uwsgi python module/n");		exit(1);	}	Py_INCREF((PyObject *) &uwsgi_InputType);	up.embedded_dict = PyModule_GetDict(new_uwsgi_module);	if (!up.embedded_dict) {		uwsgi_log("could not get uwsgi module __dict__/n");		exit(1);	}	// just for safety	Py_INCREF(up.embedded_dict);	if (PyDict_SetItemString(up.embedded_dict, "version", PyString_FromString(UWSGI_VERSION))) {		PyErr_Print();		exit(1);	}	PyObject *uwsgi_py_version_info = PyTuple_New(5);	PyTuple_SetItem(uwsgi_py_version_info, 0, PyInt_FromLong(UWSGI_VERSION_BASE));	PyTuple_SetItem(uwsgi_py_version_info, 1, PyInt_FromLong(UWSGI_VERSION_MAJOR));	PyTuple_SetItem(uwsgi_py_version_info, 2, PyInt_FromLong(UWSGI_VERSION_MINOR));	PyTuple_SetItem(uwsgi_py_version_info, 3, PyInt_FromLong(UWSGI_VERSION_REVISION));	PyTuple_SetItem(uwsgi_py_version_info, 4, PyString_FromString(UWSGI_VERSION_CUSTOM));	if (PyDict_SetItemString(up.embedded_dict, "version_info", uwsgi_py_version_info)) {		PyErr_Print();		exit(1);	}	if (PyDict_SetItemString(up.embedded_dict, "hostname", PyString_FromStringAndSize(uwsgi.hostname, uwsgi.hostname_len))) {		PyErr_Print();		exit(1);	}	if (uwsgi.mode) {		if (PyDict_SetItemString(up.embedded_dict, "mode", PyString_FromString(uwsgi.mode))) {			PyErr_Print();			exit(1);		}	}	if (uwsgi.pidfile) {		if (PyDict_SetItemString(up.embedded_dict, "pidfile", PyString_FromString(uwsgi.pidfile))) {			PyErr_Print();			exit(1);		}	}#ifdef UWSGI_SPOOLER	if (uwsgi.spoolers) {		int sc = 0;		struct uwsgi_spooler *uspool = uwsgi.spoolers;		while(uspool) { sc++; uspool = uspool->next;}		PyObject *py_spooler_tuple = PyTuple_New(sc);		uspool = uwsgi.spoolers;		sc = 0;		while(uspool) {			PyTuple_SetItem(py_spooler_tuple, sc, PyString_FromString(uspool->dir));			sc++;			uspool = uspool->next;		}		if (PyDict_SetItemString(up.embedded_dict, "spoolers", py_spooler_tuple)) {                	PyErr_Print();                	exit(1);        	}//.........这里部分代码省略.........

void init_uwsgi_vars() {	PyObject *pysys, *pysys_dict, *pypath;	PyObject *modules = PyImport_GetModuleDict();	PyObject *tmp_module;	/* add cwd to pythonpath */	pysys = PyImport_ImportModule("sys");	if (!pysys) {		PyErr_Print();		exit(1);	}	pysys_dict = PyModule_GetDict(pysys);#ifdef PYTHREE	// fix stdout and stderr	PyObject *new_stdprint = PyFile_NewStdPrinter(2);	PyDict_SetItemString(pysys_dict, "stdout", new_stdprint);	PyDict_SetItemString(pysys_dict, "__stdout__", new_stdprint);	PyDict_SetItemString(pysys_dict, "stderr", new_stdprint);	PyDict_SetItemString(pysys_dict, "__stderr__", new_stdprint);#endif	pypath = PyDict_GetItemString(pysys_dict, "path");	if (!pypath) {		PyErr_Print();		exit(1);	}	if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(".")) != 0) {		PyErr_Print();	}	struct uwsgi_string_list *uppp = up.python_path;	while(uppp) {		if (PyList_Insert(pypath, 0, UWSGI_PYFROMSTRING(uppp->value)) != 0) {			PyErr_Print();		}		else {			uwsgi_log("added %s to pythonpath./n", uppp->value);		}		uppp = uppp->next;	}	struct uwsgi_string_list *uppma = up.pymodule_alias;	while(uppma) {		// split key=value		char *value = strchr(uppma->value, '=');		if (!value) {			uwsgi_log("invalid pymodule-alias syntax/n");			goto next;		}		value[0] = 0;		if (!strchr(value + 1, '/')) {			// this is a standard pymodule			tmp_module = PyImport_ImportModule(value + 1);			if (!tmp_module) {				PyErr_Print();				exit(1);			}			PyDict_SetItemString(modules, uppma->value, tmp_module);		}		else {			// this is a filepath that need to be mapped			tmp_module = uwsgi_pyimport_by_filename(uppma->value, value + 1);			if (!tmp_module) {				PyErr_Print();				exit(1);			}		}		uwsgi_log("mapped virtual pymodule /"%s/" to real pymodule /"%s/"/n", uppma->value, value + 1);		// reset original value		value[0] = '=';next:		uppma = uppma->next;	}}

PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {#ifdef UWSGI_PYPY	uwsgi_log("import by filename is currently not supported on PyPy !!!/n");	return NULL;#else	FILE *pyfile;	struct _node *py_file_node = NULL;	PyObject *py_compiled_node, *py_file_module;	int is_a_package = 0;	struct stat pystat;	char *real_filename = filename;	if (!uwsgi_check_scheme(filename)) {		pyfile = fopen(filename, "r");		if (!pyfile) {			uwsgi_log("failed to open python file %s/n", filename);			return NULL;		}		if (fstat(fileno(pyfile), &pystat)) {			uwsgi_error("fstat()");			return NULL;		}		if (S_ISDIR(pystat.st_mode)) {			is_a_package = 1;			fclose(pyfile);			real_filename = uwsgi_concat2(filename, "/__init__.py");			pyfile = fopen(real_filename, "r");			if (!pyfile) {				uwsgi_error_open(real_filename);				free(real_filename);				return NULL;			}		}		py_file_node = PyParser_SimpleParseFile(pyfile, real_filename, Py_file_input);		if (!py_file_node) {			PyErr_Print();			uwsgi_log("failed to parse file %s/n", real_filename);			if (is_a_package)				free(real_filename);			fclose(pyfile);			return NULL;		}		fclose(pyfile);	}	else {		int pycontent_size = 0;		char *pycontent = uwsgi_open_and_read(filename, &pycontent_size, 1, NULL);		if (pycontent) {			py_file_node = PyParser_SimpleParseString(pycontent, Py_file_input);			if (!py_file_node) {				PyErr_Print();				uwsgi_log("failed to parse url %s/n", real_filename);				return NULL;			}		}	}	py_compiled_node = (PyObject *) PyNode_Compile(py_file_node, real_filename);	if (!py_compiled_node) {		PyErr_Print();		uwsgi_log("failed to compile python file %s/n", real_filename);		return NULL;	}	if (is_a_package) {		py_file_module = PyImport_AddModule(name);		if (py_file_module) {			PyModule_AddObject(py_file_module, "__path__", Py_BuildValue("[O]", PyString_FromString(filename)));		}		free(real_filename);	}	py_file_module = PyImport_ExecCodeModule(name, py_compiled_node);	if (!py_file_module) {		PyErr_Print();		return NULL;	}	Py_DECREF(py_compiled_node);	return py_file_module;#endif}

int uwsgi_python_init() {#ifndef UWSGI_PYPY	char *pyversion = strchr(Py_GetVersion(), '/n');	if (!pyversion) {        	uwsgi_log_initial("Python version: %s/n", Py_GetVersion());	}	else {        	uwsgi_log_initial("Python version: %.*s %s/n", pyversion-Py_GetVersion(), Py_GetVersion(), Py_GetCompiler()+1);	}#else	uwsgi_log_initial("PyPy version: %s/n", PYPY_VERSION);#endif	if (up.home != NULL) {#ifdef PYTHREE		wchar_t *wpyhome;		wpyhome = malloc((sizeof(wchar_t) * strlen(up.home)) + sizeof(wchar_t) );		if (!wpyhome) {			uwsgi_error("malloc()");			exit(1);		}		mbstowcs(wpyhome, up.home, strlen(up.home));		Py_SetPythonHome(wpyhome);		// do not free this memory !!!		//free(wpyhome);#else		Py_SetPythonHome(up.home);#endif		uwsgi_log("Set PythonHome to %s/n", up.home);	}#ifdef PYTHREE	wchar_t pname[6];	mbstowcs(pname, "uWSGI", 6);	Py_SetProgramName(pname);#else	Py_SetProgramName("uWSGI");#endif#ifndef UWSGI_PYPY	Py_OptimizeFlag = up.optimize;#endif	Py_Initialize();	if (!uwsgi.has_threads) {		uwsgi_log("*** Python threads support is disabled. You can enable it with --enable-threads ***/n");	}	up.wsgi_spitout = PyCFunction_New(uwsgi_spit_method, NULL);	up.wsgi_writeout = PyCFunction_New(uwsgi_write_method, NULL);	up.main_thread = PyThreadState_Get();        // by default set a fake GIL (little impact on performance)        up.gil_get = gil_fake_get;        up.gil_release = gil_fake_release;        up.swap_ts = simple_swap_ts;        up.reset_ts = simple_reset_ts;		uwsgi_log_initial("Python main interpreter initialized at %p/n", up.main_thread);	return 1;}

void *uwsgi_python_autoreloader_thread(void *foobar) {	PyObject *modules;	// block signals on this thread	sigset_t smask;        sigfillset(&smask);#ifndef UWSGI_DEBUG        sigdelset(&smask, SIGSEGV);#endif        pthread_sigmask(SIG_BLOCK, &smask, NULL);	PyThreadState *pts = PyThreadState_New(up.main_thread->interp);	pthread_setspecific(up.upt_save_key, (void *) pts);        pthread_setspecific(up.upt_gil_key, (void *) pts);	UWSGI_GET_GIL;	PyObject *threading_module = PyImport_ImportModule("threading");	if (threading_module) {		PyObject *threading_module_dict = PyModule_GetDict(threading_module);                if (threading_module_dict) {#ifdef PYTHREE                        PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "current_thread");#else                        PyObject *threading_current = PyDict_GetItemString(threading_module_dict, "currentThread");#endif                        if (threading_current) {                                PyObject *current_thread = PyEval_CallObject(threading_current, (PyObject *)NULL);                                if (!current_thread) {                                        // ignore the error                                        PyErr_Clear();                                }                                else {                                        PyObject_SetAttrString(current_thread, "name", PyString_FromString("uWSGIAutoReloader"));                                        Py_INCREF(current_thread);					modules = PyImport_GetModuleDict();					goto cycle;                                }                        }                }	}	return NULL;cycle:	if (uwsgi.mywid == 1) {		uwsgi_log("Python auto-reloader enabled/n");	}	PyObject *times_dict = PyDict_New();	char *filename;	for(;;) {		UWSGI_RELEASE_GIL;		sleep(up.auto_reload);		UWSGI_GET_GIL;		// do not start monitoring til the first app is loaded (required for lazy mode)		if (uwsgi_apps_cnt == 0) continue;#ifdef UWSGI_PYTHON_OLD                int pos = 0;#else                Py_ssize_t pos = 0;#endif		PyObject *mod_name, *mod;                while (PyDict_Next(modules, &pos, &mod_name, &mod)) {			int found = 0;			struct uwsgi_string_list *usl = up.auto_reload_ignore;			while(usl) {				if (!strcmp(usl->value, PyString_AsString(mod_name))) {					found = 1;					break;				}				usl = usl->next;			}			if (found) continue;			if (!PyObject_HasAttrString(mod, "__file__")) continue;			PyObject *mod_file = PyObject_GetAttrString(mod, "__file__");			if (!mod_file) continue;#ifdef PYTHREE			PyObject *zero = PyUnicode_AsUTF8String(mod_file);			char *mod_filename = PyString_AsString(zero);#else			char *mod_filename = PyString_AsString(mod_file);#endif			if (!mod_filename) {#ifdef PYTHREE				Py_DECREF(zero);#endif				continue;			}			char *ext = strrchr(mod_filename, '.');			if (ext && (!strcmp(ext+1, "pyc") || !strcmp(ext+1, "pyd") || !strcmp(ext+1, "pyo"))) {				filename = uwsgi_concat2n(mod_filename, strlen(mod_filename)-1, "", 0);			}			else {				filename = uwsgi_concat2(mod_filename, "");			}			if (uwsgi_check_python_mtime(times_dict, filename)) {				UWSGI_RELEASE_GIL;				return NULL;			}			free(filename);#ifdef PYTHREE			Py_DECREF(zero);//.........这里部分代码省略.........

void uwsgi_python_init_apps() {	struct http_status_codes *http_sc;#ifndef UWSGI_PYPY	// prepare for stack suspend/resume	if (uwsgi.async > 1) {		up.current_recursion_depth = uwsgi_malloc(sizeof(int)*uwsgi.async);        	up.current_frame = uwsgi_malloc(sizeof(struct _frame)*uwsgi.async);	}#endif        // setup app loaders#ifdef UWSGI_MINTERPRETERS        up.loaders[LOADER_DYN] = uwsgi_dyn_loader;#endif        up.loaders[LOADER_UWSGI] = uwsgi_uwsgi_loader;        up.loaders[LOADER_FILE] = uwsgi_file_loader;        up.loaders[LOADER_PASTE] = uwsgi_paste_loader;        up.loaders[LOADER_EVAL] = uwsgi_eval_loader;        up.loaders[LOADER_MOUNT] = uwsgi_mount_loader;        up.loaders[LOADER_CALLABLE] = uwsgi_callable_loader;        up.loaders[LOADER_STRING_CALLABLE] = uwsgi_string_callable_loader;	struct uwsgi_string_list *upli = up.import_list;	while(upli) {		if (strchr(upli->value, '/') || uwsgi_endswith(upli->value, ".py")) {			uwsgi_pyimport_by_filename(uwsgi_pythonize(upli->value), upli->value);		}		else {			if (PyImport_ImportModule(upli->value) == NULL) {				PyErr_Print();			}		}		upli = upli->next;	}	struct uwsgi_string_list *uppa = up.post_pymodule_alias;	PyObject *modules = PyImport_GetModuleDict();	PyObject *tmp_module;	while(uppa) {                // split key=value                char *value = strchr(uppa->value, '=');                if (!value) {                        uwsgi_log("invalid pymodule-alias syntax/n");			goto next;                }                value[0] = 0;                if (!strchr(value + 1, '/')) {                        // this is a standard pymodule                        tmp_module = PyImport_ImportModule(value + 1);                        if (!tmp_module) {                                PyErr_Print();                                exit(1);                        }                        PyDict_SetItemString(modules, uppa->value, tmp_module);                }                else {                        // this is a filepath that need to be mapped                        tmp_module = uwsgi_pyimport_by_filename(uppa->value, value + 1);                        if (!tmp_module) {                                PyErr_Print();                                exit(1);                        }                }                uwsgi_log("mapped virtual pymodule /"%s/" to real pymodule /"%s/"/n", uppa->value, value + 1);                // reset original value                value[0] = '=';next:		uppa = uppa->next;        }	if (up.wsgi_config != NULL) {		init_uwsgi_app(LOADER_UWSGI, up.wsgi_config, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);	}	if (up.file_config != NULL) {		init_uwsgi_app(LOADER_FILE, up.file_config, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);	}	if (up.paste != NULL) {		init_uwsgi_app(LOADER_PASTE, up.paste, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);	}	if (up.eval != NULL) {		init_uwsgi_app(LOADER_EVAL, up.eval, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);	}	if (up.web3 != NULL) {		init_uwsgi_app(LOADER_UWSGI, up.web3, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WEB3);	}	if (up.pump != NULL) {		init_uwsgi_app(LOADER_UWSGI, up.pump, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_PUMP);		// filling http status codes        	for (http_sc = hsc; http_sc->message != NULL; http_sc++) {                	http_sc->message_size = (int) strlen(http_sc->message);        	}	}	if (up.wsgi_lite != NULL) {//.........这里部分代码省略.........