Using global configuration variable instead of function arguments

include/conf.h

@@ -90,6 +90,8 @@
 You can escape { and } by using {{ and }} and all field names can by\n\
 abbreviated to one character.\n"
 
+#define PYENTRY_DEFAULT_FUN "application"
+
 /**@brief Friendly name for @ref struct pyfcgi_conf_s
  * @see struct pyfcgi_conf_s */
 typedef struct pyfcgi_conf_s pyfcgi_conf_t;
@@ -143,6 +145,9 @@ void usage();
 /**@brief Print pyfcgi & python version on given fd */
 void print_version(int);
 
+/**@brief Init conf with default values */
+void default_conf();
+
 /**@brief Parse arguments and store them in conf
  * @return 0 if no error */
 int parse_args(int argc, char *argv[]);

include/logger.h

@@ -324,7 +324,7 @@ int pyfcgi_logger_stop();
 /**@brief Enable syslog logging with given ident
  * @param char* ident if NULL use current ident
  */
-void pyfcgi_logger_enable_syslog(char*);
+void pyfcgi_logger_enable_syslog(const char*);
 
 /**@brief Stop & free an individual logger */
 void _pyfcgi_logger_free(pyfcgi_logger_t*);

include/pyworker.h

@@ -109,7 +109,7 @@ struct piper_args_s
  * @param int max request before worker restart
  * @return 0 if exit avec max requests
  */
-int work(char*, int, int, int);
+int work(int, int);
 
 /**@brief function for a subprocess designed to read stdin & stdout from
  * python & forward them to syslog or FCGI
@@ -139,8 +139,9 @@ void worker_piper_sighandler(int);
 int ctl_get_rep_sz(int, size_t*);
 
 /**@brief Import & return the python entrypoint callable
+ * from PyFCGI_conf.py_entrymod & PyFCGI_conf.py_entryfun
  */
-PyObject* import_entrypoint(char* py_entrypoint);
+PyObject* import_entrypoint();
 
 /**@brief Fetch stdout & stderr python flush() function
  * @param PyObject* pystdout_flush

include/responder.h

@@ -67,26 +67,24 @@ void init_context();
  * The main function of the fcgi app fork child
  * @param int max_requests : exit normally after this number of requests. If
  * 0 given never exit.
- * @param char* python_entrypoint a path to a python entrypoint
+ * @param char* python_entrymodule a python module name
+ * @param char* python_entrymodule a python callable name from entry module
  * @param unsigned int max_requests before exiting worker
  * @param unsigned int minimum workers count
  * @param unsigned int maximum wrokers count
  * @return 0 on success
  */
-int responder_loop(char *py_entrypoint, unsigned int max_reqs,
-	unsigned int min_wrk, unsigned int max_wrk);
+int responder_loop();
 
 
 /**@brief Spawn a worker given an entrypoint
  * @ingroup work_master_proc
  * Spawn a new worker process and prepare ENV & request forwarding
- * @param char* python_entrypoint a path to a python entrypoint
  * @param int worker uid
  * @param int semid for FCGI access
- * @param int max request before worker restart
  * @return child PID
  */
-pid_t spawn(char*, int, int, int);
+pid_t spawn(int, int);
 
 /**@brief Generate a new semaphore from given key
  * @ingroup work_master_proc

src/conf.c

@@ -5,7 +5,7 @@ void usage()
 	static const struct option opts[] = PYFCGI_LONG_OPT;
 	static const char *help[][2] = PYFCGI_OPT_HELP;
 	size_t i;
-	dprintf(2, "Usage : %s -e PYMODULE -E PYFUN [OPTIONS]\n", PYFCGI_NAME);
+	dprintf(2, "Usage : %s -e PYMODULE [-E PYFUN] [OPTIONS]\n", PYFCGI_NAME);
 	dprintf(2, "\nOptions list :\n");
 	i=0;
 	while(opts[i].name)
@@ -33,12 +33,24 @@ void usage()
 void print_version(int fd)
 {
 	dprintf(fd, "%s\n", PACKAGE_STRING);
+	/**@todo TODO : get python version */
+}
+
+void default_conf()
+{
+	memset(&PyFCGI_conf, 0, sizeof(pyfcgi_conf_t));
+	PyFCGI_conf.context.pid = getpid();
+	PyFCGI_conf.min_wrk = 1;
+	PyFCGI_conf.max_wrk = 5;
+	PyFCGI_conf.max_reqs = 1000;
 }
 
 int parse_args(int argc, char *argv[])
 {
 	static const struct option long_options[] = PYFCGI_LONG_OPT;
+	char ident[] = "pyfcgi[XXXXXXXX]";
 	int c, opt_i;
+
 	while(1)
 	{
 		c = getopt_long(argc, argv, PYFCGI_SHORT_OPT, long_options,
@@ -78,7 +90,8 @@ int parse_args(int argc, char *argv[])
 				}
 				break;
 			case 'S':
-				PyFCGI_conf.logs.flags |= PYFCGI_LOG_FSYSLOG;
+				snprintf(ident+7, 8, "%4d]", PyFCGI_conf.context.pid);
+				pyfcgi_logger_enable_syslog(ident);
 				break;
 			case 'P':
 				PyFCGI_conf.context.pidfile = strdup(optarg);
@@ -100,6 +113,16 @@ int parse_args(int argc, char *argv[])
 		usage();
 		exit(1);
 	}
+	if(!PyFCGI_conf.py_entrymod)
+	{
+		dprintf(2, "No python entry module given... exiting\n");
+		usage();
+		exit(2);
+	}
+	if(!PyFCGI_conf.py_entryfun)
+	{
+		PyFCGI_conf.py_entryfun = PYENTRY_DEFAULT_FUN;
+	}
 	return 0;
 }
 

src/logger.c

@@ -32,7 +32,7 @@ int pyfcgi_logger_stop()
 	return 0;
 }
 
-void pyfcgi_logger_enable_syslog(char* nident)
+void pyfcgi_logger_enable_syslog(const char* nident)
 {
 	pyfcgi_conf_logger_t *conf;
 	conf = &PyFCGI_conf.logs;
@@ -45,7 +45,12 @@ void pyfcgi_logger_enable_syslog(char* nident)
 	{
 		nident = conf->ident;
 	}
-	openlog(nident, LOG_CONS | LOG_PERROR, LOG_DAEMON | LOG_USER);
+	if(conf->syslog_ident)
+	{
+		free(conf->syslog_ident);
+	}
+	conf->syslog_ident = strdup(nident);
+	openlog(conf->syslog_ident, LOG_CONS | LOG_PERROR, LOG_DAEMON | LOG_USER);
 }
 
 void _pyfcgi_logger_free(pyfcgi_logger_t *logger)

src/main.c

@@ -52,13 +52,10 @@ extern pyfcgi_conf_t PyFCGI_conf;
 
 int main(int argc, char **argv)
 {
-	char *ident, *py_entrypoint;
-	size_t ident_len;
 	pid_t child;
 	int child_ret;
 	unsigned int emerg_sleep = 3;
 
-	py_entrypoint = getenv("PY_ENTRYPOINT");
 	/*
 	if(argc > 1 || !py_entrypoint)
 	{
@@ -70,17 +67,20 @@ int main(int argc, char **argv)
 		return 1;
 	}
 	*/
+	default_conf();
+	pyfcgi_logger_init();
+	pyfcgi_logger_set_ident("pyfcgi(main)");
 	if(parse_args(argc, argv))
 	{
 		return 1;
 	}
 
-PyFCGI_conf.context.pid = getpid();
 
-	pyfcgi_logger_init();
-	pyfcgi_logger_set_ident("pyfcgi(main)");
-	pyfcgi_logger_add("/tmp/pyfcgi.log", 0xFF, 0xFF, NULL);
+	//pyfcgi_logger_add("/tmp/pyfcgi.log", 0xFF, 0xFF, NULL);
 
+	/*
+	cahr *ident;
+	size_t ident_len;
 	ident_len = snprintf(NULL, 0, IDENT_FMT, getpid());
 	ident_len++;
 	ident = malloc(sizeof(char)*ident_len);
@@ -91,7 +91,8 @@ PyFCGI_conf.context.pid = getpid();
 	}
 	snprintf(ident, ident_len, IDENT_FMT, getpid());
 	pyfcgi_logger_enable_syslog(ident);
-
+	free(ident);
+	*/
 
 	pyfcgi_log(LOG_INFO, "New server started");
 
@@ -107,7 +108,7 @@ PyFCGI_conf.context.pid = getpid();
 		}
 		else if(!child)
 		{
-			responder_loop(py_entrypoint, MAX_REQS, 1, 10);
+			responder_loop();
 			exit((unsigned char)-1);
 		}
 		waitpid(child, &child_ret, 0);
@@ -128,7 +129,6 @@ PyFCGI_conf.context.pid = getpid();
 	}
 
 	closelog();
-	free(ident);
 }
 
 /**@mainpage PyFCGI

src/pyworker.c

@@ -21,13 +21,14 @@
 
 static int worker_piper_sigrcv = 0;
 
-int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
+int work(int wrk_id, int semid)
 {
 	PyObject *entry_fun, *pystdout_flush, *pystderr_flush,
 	         *py_osmod;
 	FCGX_Stream *in_stream, *out_stream, *err_stream;
 	char **envp;
 	int count, pipe_out[2], pipe_err[2], pipe_ctl[2], err, piper_status;
+	int max_reqs;
 	struct sembuf sop;
 	struct sigaction act;
 	struct timeval start, stop;
@@ -37,7 +38,7 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	piper_args_t piper_args;
 	char *piper_stack;
 
-
+	max_reqs = PyFCGI_conf.max_reqs;
 	piper_args.wrk_id = wrk_id;
 	piper_args.act = &act;
 	sop.sem_num = 0;
@@ -89,11 +90,11 @@ int work(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	}
 
 	// loading module
-	entry_fun = import_entrypoint(py_entrypoint);
+	entry_fun = import_entrypoint();
 
 	pyfcgi_log(	LOG_INFO,
 		"Worker[%d] Waiting request with %s.%s()", wrk_id,
-		py_entrypoint, PYENTRY_FUNNAME);
+		PyFCGI_conf.py_entrymod, PyFCGI_conf.py_entryfun);
 
 
 	sop.sem_op = 1; //indicate worker as ready & idle
@@ -445,10 +446,10 @@ int ctl_get_rep_sz(int ctl_pipe, size_t* rep_sz)
 	return 0;
 }
 
-PyObject* import_entrypoint(char* py_entrypoint)
+PyObject* import_entrypoint()
 {
 	PyObject *entry_fname, *entry_module, *entry_fun;
-	entry_fname = PyUnicode_DecodeFSDefault(py_entrypoint);
+	entry_fname = PyUnicode_DecodeFSDefault(PyFCGI_conf.py_entrymod);
 	entry_module = PyImport_Import(entry_fname);
 	Py_DECREF(entry_fname);
 
@@ -457,7 +458,7 @@ PyObject* import_entrypoint(char* py_entrypoint)
 		//TODO syslog python error / traceback
 		pyfcgi_log(	LOG_CRIT,
 			"Unable to import python file '%s'",
-			py_entrypoint);
+			PyFCGI_conf.py_entrymod);
 		pyfcgi_log( LOG_INFO,
 			"%s", getcwd(NULL, 256));
 		log_expt(LOG_ERR);
@@ -466,7 +467,7 @@ PyObject* import_entrypoint(char* py_entrypoint)
 	}
 
 	// getting entrypoint function
-	entry_fun = PyObject_GetAttrString(entry_module, PYENTRY_FUNNAME);
+	entry_fun = PyObject_GetAttrString(entry_module, PyFCGI_conf.py_entryfun);
 	Py_DECREF(entry_module);
 
 	if(!entry_fun)
@@ -474,14 +475,14 @@ PyObject* import_entrypoint(char* py_entrypoint)
 		//TODO syslog python error / traceback
 		pyfcgi_log(	LOG_CRIT,
 			"Unable to import object '%s' from '%s'",
-			PYENTRY_FUNNAME, py_entrypoint);
+			PyFCGI_conf.py_entryfun, PyFCGI_conf.py_entrymod);
 		Py_Exit(2);
 	}
 	if(!PyCallable_Check(entry_fun))
 	{
 		pyfcgi_log( LOG_CRIT,
 			"When imported from '%s', '%s' was not a callable",
-			py_entrypoint, PYENTRY_FUNNAME);
+			PyFCGI_conf.py_entrymod, PyFCGI_conf.py_entryfun);
 		Py_Exit(3);
 	}
 	return entry_fun;

src/responder.c

@@ -25,8 +25,7 @@ void init_context()
 }
 
 
-int responder_loop(char *py_entrypoint, unsigned int max_reqs,
-	unsigned int min_wrk, unsigned int max_wrk)
+int responder_loop()
 {
 	unsigned int n_wrk, wanted_n, n;
 	pid_t *wrk_pids;
@@ -48,7 +47,7 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 
 	init_context();
 
-	wrk_pids = malloc(sizeof(int) * max_wrk);
+	wrk_pids = malloc(sizeof(int) * PyFCGI_conf.max_wrk);
 	if(!wrk_pids)
 	{
 		err = errno;
@@ -57,16 +56,16 @@ int responder_loop(char *py_entrypoint, unsigned int max_reqs,
 			strerror(err));
 		clean_exit(err);
 	}
-	bzero(wrk_pids, sizeof(int) * max_wrk);
+	bzero(wrk_pids, sizeof(int) * PyFCGI_conf.max_wrk);
 
 	semid = new_semaphore();
 	
-	wanted_n = min_wrk;
+	wanted_n = PyFCGI_conf.min_wrk;
 	n_wrk = 0;
 	// prespawning minimum worker count
 	for(n_wrk=0; n_wrk < wanted_n; n_wrk++)
 	{
-		wrk_pids[n_wrk] = spawn(py_entrypoint, n_wrk, semid, max_reqs);
+		wrk_pids[n_wrk] = spawn(n_wrk, semid);
 	}
 	//Wait at least for a process to be ready
 	while(!semtimedop(semid, &sop, 1, &timeout));
@@ -135,8 +134,7 @@ pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 			else
 			{	// respawn on same slot
 				pyfcgi_log(LOG_INFO, "respawn #%d", n);
-				wrk_pids[n] = spawn(py_entrypoint, n,
-				                    semid, max_reqs);
+				wrk_pids[n] = spawn(n, semid);
 				continue;
 			}
 		}
@@ -153,7 +151,8 @@ pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 				{
 					idle = 1;
 				}
-				else if(wanted_n > min_wrk && n_wrk - wanted_n < 2)
+				else if(wanted_n > PyFCGI_conf.min_wrk
+					&& n_wrk - wanted_n < 2)
 				{
 					wanted_n--;
 				}
@@ -162,7 +161,7 @@ pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 			pyfcgi_log(LOG_ERR, "Unable to read semaphore : %s",
 			       strerror(err));
 		}
-		if(!ret && n_wrk < max_wrk)
+		if(!ret && n_wrk < PyFCGI_conf.max_wrk)
 		{
 			idle=0;
 			pyfcgi_log( LOG_DEBUG,
@@ -170,13 +169,12 @@ pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 			n = n_wrk;
 			n_wrk++;
 			wanted_n = n_wrk;
-			wrk_pids[n] = spawn(py_entrypoint, n,
-					    semid, max_reqs);
+			wrk_pids[n] = spawn(n, semid);
 		}
 	}
 	
 	//Debug wait & exit
-	for(n_wrk=0; n_wrk != min_wrk; n_wrk++)
+	for(n_wrk=0; n_wrk != PyFCGI_conf.min_wrk; n_wrk++)
 	{
 		waitpid(wrk_pids[n_wrk], &status, 0);
 		pyfcgi_log(LOG_DEBUG, "Child %d stopped with status %d",
@@ -187,7 +185,7 @@ pyfcgi_log( LOG_DEBUG, "GC want %d have %d", wanted_n, n_wrk);
 	exit(0);
 }
 
-pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
+pid_t spawn(int wrk_id, int semid)
 {
 	pid_t res;
 	struct timespec timeout;
@@ -198,14 +196,14 @@ pid_t spawn(char* py_entrypoint, int wrk_id, int semid, int max_reqs)
 	res = fork();
 	if(res == -1)
 	{
-		pyfcgi_log(	LOG_ERR, "Fork fails for worker #%d : %s",
+		pyfcgi_log(LOG_ERR, "Fork fails for worker #%d : %s",
 			wrk_id, strerror(errno));
 		return -1;
 	}
 	else if(!res)
 	{
 		// Child process
-		exit(work(py_entrypoint, wrk_id, semid, max_reqs));
+		exit(work(wrk_id, semid));
 	}
 	// Sleep to avoid spawning like hell thinking all workers are
 	// busy. Let some time to this one to go up...