Merge lp:~xnox/upstart/async-no-process-run into lp:upstart/async

[Dimitri John Ledkov]

[Dimitri John Ledkov (xnox)]

Depends on https://code.launchpad.net/~xnox/upstart/async-failed-pid-to-zero/+merge/220513

=== modified file 'init/job_process.c'
--- init/job_process.c	2014-05-21 16:52:42 +0000
+++ init/job_process.c	2014-05-21 22:55:26 +0000
@@ -149,234 +149,6 @@
 extern int           session_end;
 extern time_t        quiesce_phase_time;
 
-/**
- * job_process_run:
- * @job: job context for process to be run in,
- * @process: job process to run.
- *
- * This function looks up @process in the job's process table and uses
- * the information there to spawn a new process for the @job, storing the
- * pid in that table entry.
- *
- * The process is normally executed using the system shell, unless the
- * script member of @process is FALSE and there are no typical shell
- * characters within the command member, in which case it is executed
- * directly using exec after splitting on whitespace.
- *
- * When executed with the shell, if the command (which may be an entire
- * script) is reasonably small (less than 1KB) it is passed to the
- * shell using the POSIX-specified -c option.  Otherwise the shell is told
- * to read commands from one of the special /proc/self/fd/NN devices and NihIo
- * used to feed the script into that device.  A pointer to the NihIo object
- * is not kept or stored because it will automatically clean itself up should
- * the script go away as the other end of the pipe will be closed.
- *
- * In either case the shell is run with the -e option so that commands will
- * fail if their exit status is not checked.
- *
- * This function will block until the job_process_spawn() call succeeds or
- * a non-temporary error occurs (such as file not found).  It is up to the
- * called to decide whether non-temporary errors are a reason to change the
- * job state or not.
- *
- * Returns: zero on success, negative value on non-temporary error.
- **/
-int
-job_process_run (Job         *job,
-		 ProcessType  process)
-{
-	Process         *proc;
-	nih_local char **argv = NULL;
-	nih_local char **env = NULL;
-	nih_local char  *script = NULL;
-	char           **e;
-	size_t           argc, envc;
-	int              fds[2] = { -1, -1 };
-	int              error = FALSE, trace = FALSE, shell = FALSE;
-
-	nih_assert (job != NULL);
-
-	proc = job->class->process[process];
-	nih_assert (proc != NULL);
-	nih_assert (proc->command != NULL);
-
-	/* We run the process using a shell if it says it wants to be run
-	 * as such, or if it contains any shell-like characters; since that's
-	 * the best way to deal with things like variables.
-	 */
-	if ((proc->script) || strpbrk (proc->command, SHELL_CHARS)) {
-		char *nl, *p;
-
-		argc = 0;
-		argv = NIH_MUST (nih_str_array_new (NULL));
-
-		NIH_MUST (nih_str_array_add (&argv, NULL, &argc, SHELL));
-		NIH_MUST (nih_str_array_add (&argv, NULL, &argc, "-e"));
-
-		/* If the process wasn't originally marked to be run through
-		 * a shell, prepend exec to the script so that the shell
-		 * gets out of the way after parsing.
-		 */
-		if (proc->script) {
-			script = NIH_MUST (nih_strdup (NULL, proc->command));
-		} else {
-			script = NIH_MUST (nih_sprintf (NULL, "exec %s",
-							proc->command));
-		}
-
-		/* Don't pipe single-line scripts into the shell using
-		 * /proc/self/fd/NNN, instead just pass them over the
-		 * command-line (taking care to strip off the trailing
-		 * newlines).
-		 */
-		p = nl = strchr (script, '\n');
-		while (p && (*p == '\n'))
-			p++;
-
-		if ((! nl) || (! *p)) {
-			/* Strip off the newline(s) */
-			if (nl)
-				*nl = '\0';
-
-			NIH_MUST (nih_str_array_add (&argv, NULL,
-						     &argc, "-c"));
-			NIH_MUST (nih_str_array_addp (&argv, NULL,
-						      &argc, script));
-
-			/* Next argument is argv[0]; just pass the shell */
-			NIH_MUST (nih_str_array_add (&argv, NULL,
-						     &argc, SHELL));
-		} else {
-			nih_local char *cmd = NULL;
-
-			/* Close the writing end when the child is exec'd */
-			NIH_ZERO (pipe (fds));
-			nih_io_set_cloexec (fds[1]);
-
-			shell = TRUE;
-
-			cmd = NIH_MUST (nih_sprintf (argv, "%s/%d",
-						     "/proc/self/fd",
-						     JOB_PROCESS_SCRIPT_FD));
-			NIH_MUST (nih_str_array_addp (&argv, NULL,
-						      &argc, cmd));
-		}
-	} else {
-		/* Split the command on whitespace to produce a list of
-		 * arguments that we can exec directly.
-		 */
-		argv = NIH_MUST (nih_str_split (NULL, proc->command,
-						" \t\r\n", TRUE));
-	}
-
-	/* We provide the standard job environment to all of its processes,
-	 * except for pre-stop which also has the stop event environment,
-	 * adding special variables that indicate which job it was -- mostly
-	 * so that initctl can have clever behaviour when called within them.
-	 */
-	envc = 0;
-	env = NIH_MUST (nih_str_array_new (NULL));
-
-	if (job->env)
-		NIH_MUST (environ_append (&env, NULL, &envc, TRUE, job->env));
-
-	if (job->stop_env
-	    && ((process == PROCESS_PRE_STOP)
-		|| (process == PROCESS_POST_STOP)))
-		for (e = job->stop_env; *e; e++)
-			NIH_MUST (environ_set (&env, NULL, &envc, TRUE, *e));
-
-	NIH_MUST (environ_set (&env, NULL, &envc, TRUE,
-			       "UPSTART_JOB=%s", job->class->name));
-	NIH_MUST (environ_set (&env, NULL, &envc, TRUE,
-			       "UPSTART_INSTANCE=%s", job->name));
-	if (user_mode)
-		NIH_MUST (environ_set (&env, NULL, &envc, TRUE,
-			       "UPSTART_SESSION=%s", control_server_address));
-
-	/* If we're about to spawn the main job and we expect it to become
-	 * a daemon or fork before we can move out of spawned, we need to
-	 * set a trace on it.
-	 */
-	if ((process == PROCESS_MAIN)
-	    && ((job->class->expect == EXPECT_DAEMON)
-		|| (job->class->expect == EXPECT_FORK)))
-		trace = TRUE;
-
-	/* Spawn the process, repeat until fork() works */
-	while ((job->pid[process] = job_process_spawn (job, argv, env,
-					trace, fds[0], process)) < 0) {
-		NihError *err;
-
-		err = nih_error_get ();
-		if (err->number == JOB_PROCESS_ERROR) {
-			/* Non-temporary error condition, we're not going
-			 * to be able to spawn this process.  Clean up after
-			 * ourselves before returning.
-			 */
-			if (shell) {
-				close (fds[0]);
-				close (fds[1]);
-			}
-
-			job->pid[process] = 0;
-
-			/* Return non-temporary error condition */
-			nih_warn (_("Failed to spawn %s %s process: %s"),
-				  job_name (job), process_name (process),
-				  err->message);
-			nih_free (err);
-			return -1;
-		} else if (! error)
-			nih_warn ("%s: %s", _("Temporary process spawn error"),
-				  err->message);
-		nih_free (err);
-
-		error = TRUE;
-	}
-
-	nih_info (_("%s %s process (%d)"),
-		  job_name (job), process_name (process), job->pid[process]);
-
-	job->trace_forks = 0;
-	job->trace_state = trace ? TRACE_NEW : TRACE_NONE;
-
-	/* Feed the script to the child process */
-	if (shell) {
-		NihIo *io;
-
-		/* Clean up and close the reading end (we don't need it) */
-		close (fds[0]);
-
-		/* Put the entire script into an NihIo send buffer and
-		 * then mark it for closure so that the shell gets EOF
-		 * and the structure gets cleaned up automatically.
-		 */
-		while (! (io = nih_io_reopen (job, fds[1], NIH_IO_STREAM,
-					      NULL, NULL, NULL, NULL))) {
-			NihError *err;
-
-			err = nih_error_get ();
-			if (err->number != ENOMEM)
-				nih_assert_not_reached ();
-			nih_free (err);
-		}
-
-		/* We're feeding using a pipe, which has a file descriptor
-		 * on the child end even though it open()s it again using
-		 * a path. Instruct the shell to close this extra fd and
-		 * not to leak it.
-		 */
-		NIH_ZERO (nih_io_printf (io, "exec %d<&-\n",
-					 JOB_PROCESS_SCRIPT_FD));
-
-		NIH_ZERO (nih_io_write (io, script, strlen (script)));
-		nih_io_shutdown (io);
-	}
-
-	return 0;
-}
-
 
 /**
  * job_process_spawn:

=== modified file 'init/job_process.h'
--- init/job_process.h	2014-05-15 09:43:13 +0000
+++ init/job_process.h	2014-05-21 22:55:26 +0000
@@ -138,11 +138,7 @@
 
 NIH_BEGIN_EXTERN
 
-int    job_process_run     (Job *job, ProcessType process);
-void
-job_process_start (Job                    *job,
-		   ProcessType             process);
-
+void   job_process_start      (Job *job, ProcessType process);
 void   job_process_run_bottom (JobProcessData *handler_data);
 
 void   job_process_child_reader (JobProcessData *handler_data, NihIo *io,

=== modified file 'init/tests/test_job.c'
--- init/tests/test_job.c	2014-05-21 22:55:26 +0000
+++ init/tests/test_job.c	2014-05-21 22:55:26 +0000
@@ -60,6 +60,7 @@
 #include "conf.h"
 #include "control.h"
 #include "state.h"
+#include "test_util_common.h"
 
 void
 job_quit_with_state (void *data, NihMainLoopFunc *loop)
@@ -69,12 +70,6 @@
     nih_main_loop_exit (job->state);
 }
 
-void
-timeout_quit_zero (void *data, NihTimerCb *timer)
-{
-    nih_main_loop_exit (0);
-}
-
 char *argv0;
 
 static int state_fd = -1;
@@ -3244,10 +3239,7 @@
 	TEST_FEATURE ("killed to post-stop for failed process");
 	tmp = class->process[PROCESS_POST_STOP];
 	class->process[PROCESS_POST_STOP] = fail;
-	NihTimer * timer;
 
-	/* FIXME this is very slow, as we wait 1s per TEST_ALLOC_FAIL itteration... */
-	nih_message ("  Running. Respect the timer.");
 	TEST_ALLOC_FAIL {
 		TEST_ALLOC_SAFE {
 			job = job_new (class, "");
@@ -3255,7 +3247,6 @@
 			blocked = blocked_new (job, BLOCKED_EVENT, cause);
 			event_block (cause);
 			nih_list_add (&job->blocking, &blocked->entry);
-			timer = nih_timer_add_timeout (NULL, 1, (NihTimerCb)timeout_quit_zero, NULL);
 		}
 
 		job->goal = JOB_START;
@@ -3272,16 +3263,12 @@
 
 		TEST_FREE_TAG (job);
 
-		TEST_FREE_TAG (timer);
-
 		TEST_DIVERT_STDERR (output) {
 			job_change_state (job, JOB_POST_STOPPING);
-			nih_main_loop ();
+			TEST_WATCH_LOOP ();
 		}
 		rewind (output);
 
-		TEST_FREE (timer);
-
 		TEST_FREE (job);
 
 		TEST_EQ (cause->blockers, 0);

=== modified file 'init/tests/test_job_process.c'
--- init/tests/test_job_process.c	2014-05-19 17:21:16 +0000
+++ init/tests/test_job_process.c	2014-05-21 22:55:26 +0000
@@ -385,7 +385,7 @@
  * (Such tests are handled in the bundled test_user_sessions.sh script).
  */
 void
-test_run (void)
+test_start (void)
 {
 	char             dirname[PATH_MAX];
 	JobClass        *class = NULL;
@@ -394,7 +394,7 @@
 	struct stat      statbuf;
 	char             filename[PATH_MAX], buf[80];
 	char             function[PATH_MAX];
-	int              ret = -1, status, first;
+	int              status;
 	siginfo_t        info;
 	char             filebuf[1024];
 	struct passwd   *pwd;
@@ -409,7 +409,7 @@
 	log_unflushed_init ();
 	job_class_init ();
 
-	TEST_FUNCTION ("job_process_run");
+	TEST_FUNCTION ("job_process_start");
 
 	TEST_FILENAME (filename);
 	program_name = "test";
@@ -443,8 +443,7 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -478,8 +477,7 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -520,8 +518,7 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -560,8 +557,7 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -601,8 +597,7 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -648,8 +643,7 @@
 						   "CRACKLE=FIZZ"));
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -704,8 +698,7 @@
 						   "CRACKLE=FIZZ"));
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -761,8 +754,7 @@
 						   "CRACKLE=FIZZ"));
 		}
 
-		ret = job_process_run (job, PROCESS_PRE_STOP);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_PRE_STOP);
 
 		TEST_NE (job->pid[PROCESS_PRE_STOP], 0);
 
@@ -819,8 +811,7 @@
 						   "CRACKLE=FIZZ"));
 		}
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
 
 		TEST_NE (job->pid[PROCESS_POST_STOP], 0);
 
@@ -870,36 +861,11 @@
 			job->state = JOB_SPAWNED;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
-		/* Loop until we've fed all of the data. */
-		first = TRUE;
-		for (;;) {
-			fd_set readfds, writefds, exceptfds;
-			int    nfds;
-
-			nfds = 0;
-			FD_ZERO (&readfds);
-			FD_ZERO (&writefds);
-			FD_ZERO (&exceptfds);
-
-			nih_io_select_fds (&nfds, &readfds,
-					   &writefds, &exceptfds);
-			if (! nfds) {
-				if (first)
-					TEST_FAILED ("expected to have "
-						     "data to feed.");
-				break;
-			}
-			first = FALSE;
-
-			select (nfds, &readfds, &writefds, &exceptfds, NULL);
-
-			nih_io_handle_fds (&readfds, &writefds, &exceptfds);
-		}
+		TEST_WATCH_LOOP ();
 
 		waitpid (job->pid[PROCESS_MAIN], &status, 0);
 		TEST_TRUE (WIFEXITED (status));
@@ -938,8 +904,7 @@
 			job->trace_state = TRACE_NORMAL;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_EQ (job->trace_forks, 0);
 		TEST_EQ (job->trace_state, TRACE_NONE);
@@ -978,8 +943,7 @@
 			job->trace_state = TRACE_NORMAL;
 		}
 
-		ret = job_process_run (job, PROCESS_PRE_START);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_PRE_START);
 
 		TEST_EQ (job->trace_forks, 0);
 		TEST_EQ (job->trace_state, TRACE_NONE);
@@ -1020,8 +984,7 @@
 			job->trace_state = TRACE_NORMAL;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_EQ (job->trace_forks, 0);
 		TEST_EQ (job->trace_state, TRACE_NEW);
@@ -1071,8 +1034,7 @@
 			job->trace_state = TRACE_NORMAL;
 		}
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_EQ (job->trace_forks, 0);
 		TEST_EQ (job->trace_state, TRACE_NEW);
@@ -1098,7 +1060,7 @@
 	}
 
 	/* Check that if we try and run a command that doesn't exist,
-	 * job_process_run() raises a ProcessError and the command doesn't
+	 * job_process_start() raises a ProcessError and the command doesn't
 	 * have any stored process id for it.
 	 */
 	TEST_FEATURE ("with no such file");
@@ -1120,11 +1082,12 @@
 		}
 
 		TEST_DIVERT_STDERR (output) {
-			ret = job_process_run (job, PROCESS_MAIN);
+			job_process_start (job, PROCESS_MAIN);
+			TEST_WATCH_LOOP ();
+			event_poll ();
 		}
 		rewind (output);
-		TEST_LT (ret, 0);
-
+		
 		TEST_EQ (job->pid[PROCESS_MAIN], 0);
 
 		TEST_FILE_EQ (output, ("test: Failed to spawn test (foo) main "
@@ -1171,8 +1134,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1239,8 +1201,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1307,8 +1268,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1375,8 +1335,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1438,8 +1397,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1475,8 +1433,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1512,8 +1469,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1559,11 +1515,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/* XXX: call 0: async process setup */
+	TEST_WATCH_UPDATE ();
+
 	/* XXX: call 1: wait for script write to child shell */
 	TEST_WATCH_UPDATE ();
 
@@ -1589,10 +1547,10 @@
 
 	/* Note we can't use TEST_ALLOC_FAIL() for this test since on
 	 * the ENOMEM loop all we could do is discard the error and
-	 * continue since job_process_run() calls job_process_spawn()
+	 * continue since job_process_start() calls job_process_spawn()
 	 * repeatedly until it works, but the alloc fails in log_new()
 	 * invoked by job_process_spawn() such that when we've left
-	 * job_process_run(), it's too late.
+	 * job_process_start(), it's too late.
 	 *
 	 * However, we test this scenario in test_spawn() so all is not
 	 * lost.
@@ -1613,8 +1571,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -1671,11 +1628,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/*  wait for read from pty allowing logger to write to log file */
 	TEST_WATCH_UPDATE ();
 
@@ -1755,11 +1714,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/*  wait for read from pty allowing logger to write to log file */
 	TEST_WATCH_UPDATE ();
 
@@ -1837,10 +1798,10 @@
 
 	/* Note we can't use TEST_ALLOC_FAIL() for this test since on
 	 * the ENOMEM loop all we could do is discard the error and
-	 * continue since job_process_run() calls job_process_spawn()
+	 * continue since job_process_start() calls job_process_spawn()
 	 * repeatedly until it works, but the alloc fails in log_new()
 	 * invoked by job_process_spawn() such that when we've left
-	 * job_process_run(), it's too late.
+	 * job_process_start(), it's too late.
 	 *
 	 * However, we test this scenario in test_spawn() so all is not
 	 * lost.
@@ -1861,11 +1822,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/* XXX: call 1: wait for script write to child shell */
 	TEST_WATCH_UPDATE ();
 
@@ -1924,11 +1887,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/*  wait for read from pty allowing logger to write to log file */
 	TEST_WATCH_UPDATE ();
 
@@ -1993,11 +1958,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/* XXX: call 1: wait for script write to child shell */
 	TEST_WATCH_UPDATE ();
 
@@ -2040,10 +2007,10 @@
 
 	/* Note we can't use TEST_ALLOC_FAIL() for this test since on
 	 * the ENOMEM loop all we could do is discard the error and
-	 * continue since job_process_run() calls job_process_spawn()
+	 * continue since job_process_start() calls job_process_spawn()
 	 * repeatedly until it works, but the alloc fails in log_new()
 	 * invoked by job_process_spawn() such that when we've left
-	 * job_process_run(), it's too late.
+	 * job_process_start(), it's too late.
 	 *
 	 * However, we test this scenario in test_spawn() so all is not
 	 * lost.
@@ -2064,8 +2031,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2111,7 +2077,7 @@
 	 * XXX: TEST_WATCH_UPDATE() *TWICE* to ensure select(2) is
 	 * XXX: called twice.
 	 *
-	 * This is required since job_process_run() uses an NihIo object
+	 * This is required since job_process_start() uses an NihIo object
 	 * to squirt the script to the shell sub-process and this
 	 * triggers select to return when the data is written to the shell.
 	 * However, we don't care about that directly - we care more about
@@ -2120,7 +2086,7 @@
 	 * written.
 	 *
 	 * Note that the 2nd call to TEST_WATCH_UPDATE would not be
-	 * required should job_process_run() simple invoke write(2) to
+	 * required should job_process_start() simple invoke write(2) to
 	 * send the data.
 	 */
 
@@ -2141,11 +2107,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
+	/*  wait for process to setup */
+	TEST_WATCH_UPDATE ();
+
 	/* XXX: call 1: wait for script write to child shell */
 	TEST_WATCH_UPDATE ();
 
@@ -2203,8 +2171,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2263,8 +2230,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2328,8 +2294,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2390,12 +2355,12 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
 	TEST_WATCH_UPDATE ();
+	TEST_WATCH_UPDATE ();
 	waitpid (job->pid[PROCESS_MAIN], &status, 0);
 	TEST_TRUE (WIFEXITED (status));
 	TEST_EQ (WEXITSTATUS (status), 0);
@@ -2450,8 +2415,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2513,8 +2477,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2573,12 +2536,12 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
 	TEST_WATCH_UPDATE ();
+	TEST_WATCH_UPDATE ();
 
 	waitpid (job->pid[PROCESS_MAIN], &status, 0);
 	TEST_TRUE (WIFEXITED (status));
@@ -2635,8 +2598,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2701,8 +2663,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2763,12 +2724,12 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
 	TEST_WATCH_UPDATE ();
+	TEST_WATCH_UPDATE ();
 
 	waitpid (job->pid[PROCESS_MAIN], &status, 0);
 	TEST_TRUE (WIFEXITED (status));
@@ -2827,8 +2788,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2889,8 +2849,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -2949,8 +2908,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3013,8 +2971,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3088,8 +3045,9 @@
 	output = tmpfile ();
 	TEST_NE_P (output, NULL);
 	TEST_DIVERT_STDERR (output) {
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
+		TEST_WATCH_UPDATE ();
+		event_poll ();
 	}
 	fclose (output);
 
@@ -3137,8 +3095,8 @@
 		job->goal = JOB_START;
 		job->state = JOB_SPAWNED;
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
+		TEST_WATCH_UPDATE ();
 
 		/* We don't expect a logfile to be written since there is no
 		 * accompanying shell to write the error.
@@ -3149,10 +3107,10 @@
 		job->goal = JOB_STOP;
 		job->state = JOB_POST_STOP;
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
 
 		TEST_NE (job->pid[PROCESS_POST_STOP], 0);
+		TEST_WATCH_UPDATE ();
 
 		/* Flush the io so that the shell on the client side
 		 * gets the data (the script to execute).
@@ -3163,8 +3121,11 @@
 		TEST_TRUE (WIFEXITED (status));
 		TEST_EQ (WEXITSTATUS (status), 0);
 
+		TEST_WATCH_UPDATE ();
+
 		/* .. but the post stop should have written data */
 		TEST_EQ (stat (filename, &statbuf), 0);
+		event_poll ();
 	}
 	fclose (output);
 
@@ -3217,8 +3178,9 @@
 		job->goal = JOB_START;
 		job->state = JOB_SPAWNED;
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
+		TEST_WATCH_UPDATE ();
+		TEST_WATCH_UPDATE ();
 
 		/* We don't expect a logfile to be written since there is no
 		 * accompanying shell to write the error.
@@ -3229,8 +3191,8 @@
 		job->goal = JOB_STOP;
 		job->state = JOB_POST_STOP;
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
+		TEST_WATCH_UPDATE ();
 
 		TEST_NE (job->pid[PROCESS_POST_STOP], 0);
 
@@ -3248,6 +3210,7 @@
 
 		/* .. but the post stop should have written data */
 		TEST_EQ (stat (filename, &statbuf), 0);
+		event_poll ();
 	}
 	fclose (output);
 
@@ -3301,8 +3264,8 @@
 		job->goal = JOB_START;
 		job->state = JOB_SPAWNED;
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
+		TEST_WATCH_UPDATE ();
 
 		/* We don't expect a logfile to be written since there is no
 		 * accompanying shell to write the error.
@@ -3313,8 +3276,8 @@
 		job->goal = JOB_STOP;
 		job->state = JOB_POST_STOP;
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
+		TEST_WATCH_UPDATE ();
 
 		TEST_NE (job->pid[PROCESS_POST_STOP], 0);
 
@@ -3327,8 +3290,11 @@
 		TEST_TRUE (WIFEXITED (status));
 		TEST_EQ (WEXITSTATUS (status), 0);
 
+		TEST_WATCH_UPDATE ();
+
 		/* .. but the post stop should have written data */
 		TEST_EQ (stat (filename, &statbuf), 0);
+		event_poll ();
 	}
 	fclose (output);
 
@@ -3381,8 +3347,8 @@
 		job->goal = JOB_START;
 		job->state = JOB_SPAWNED;
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
+		TEST_WATCH_UPDATE ();
 
 		/* We don't expect a logfile to be written since there is no
 		 * accompanying shell to write the error.
@@ -3393,12 +3359,13 @@
 		job->goal = JOB_STOP;
 		job->state = JOB_POST_STOP;
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
+		TEST_WATCH_UPDATE ();
 
 		/* Again, no file expected */
 		TEST_EQ (stat (filename, &statbuf), -1);
 		TEST_EQ (errno, ENOENT);
+		event_poll ();
 	}
 	fclose (output);
 	nih_free (class);
@@ -3439,8 +3406,7 @@
 		job->goal = JOB_START;
 		job->state = JOB_SPAWNED;
 
-		ret = job_process_run (job, PROCESS_MAIN);
-		TEST_EQ (ret, 0);
+		job_process_start (job, PROCESS_MAIN);
 
 		TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3459,8 +3425,8 @@
 		job->goal = JOB_STOP;
 		job->state = JOB_POST_STOP;
 
-		ret = job_process_run (job, PROCESS_POST_STOP);
-		TEST_LT (ret, 0);
+		job_process_start (job, PROCESS_POST_STOP);
+		TEST_WATCH_UPDATE ();
 
 		TEST_EQ (job->pid[PROCESS_POST_STOP], 0);
 	}
@@ -3500,8 +3466,8 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
+	TEST_WATCH_UPDATE ();
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3561,8 +3527,8 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
+	TEST_WATCH_UPDATE ();
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3624,8 +3590,8 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
+	TEST_WATCH_UPDATE ();
 
 	TEST_NE (job->pid[PROCESS_MAIN], 0);
 
@@ -3704,8 +3670,7 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
 
 	/* Wait for process to avoid any possibility of EAGAIN in
 	 * log_read_watch().
@@ -3778,8 +3743,9 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
+	TEST_WATCH_UPDATE ();
+	TEST_WATCH_UPDATE ();
 
 	pid = job->pid[PROCESS_MAIN];
 
@@ -3909,8 +3875,8 @@
 		TEST_EQ_P (job->log[i], NULL);
 	}
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_MAIN);
+	TEST_WATCH_UPDATE ();
 
 	pid = job->pid[PROCESS_MAIN];
 
@@ -3982,8 +3948,7 @@
 		}
 
 		TEST_DIVERT_STDERR (output) {
-			ret = job_process_run (job, PROCESS_MAIN);
-			TEST_EQ (ret, 0);
+			job_process_start (job, PROCESS_MAIN);
 		}
 		fclose (output);
 
@@ -4040,13 +4005,8 @@
 		}
 
 		TEST_DIVERT_STDERR (output) {
-			ret = job_process_run (job, PROCESS_MAIN);
-			if (geteuid() == 0 || getuid() == pwd->pw_uid) {
-				TEST_EQ (ret, 0);
-			}
-			else {
-				TEST_EQ (ret, -1);
-			}
+			job_process_start (job, PROCESS_MAIN);
+			TEST_WATCH_UPDATE ();
 		}
 
 		if (geteuid() == 0 || getuid() == pwd->pw_uid) {
@@ -4057,11 +4017,11 @@
 		}
 		else {
 			TEST_EQ (stat (filename, &statbuf), -1);
+			event_poll ();
 		}
 
 		unlink (filename);
 		nih_free (class);
-
 	}
 
 	/************************************************************/
@@ -4104,14 +4064,13 @@
 	job->goal = JOB_START;
 	job->state = JOB_SPAWNED;
 
-	ret = job_process_run (job, PROCESS_MAIN);
-	TEST_EQ (ret, 0);
-
+	job_process_start (job, PROCESS_MAIN);
+	while (stat (filename, &statbuf) != 0) {
+		TEST_WATCH_UPDATE ();
+	}
 	pid = job->pid[PROCESS_MAIN];
 	TEST_GT (pid, 0);
 
-	TEST_WATCH_UPDATE ();
-
 	TEST_EQ (stat (filename, &statbuf), 0);
 
 	output = fopen (filename, "r");
@@ -4124,8 +4083,8 @@
 
 	TEST_EQ (fclose (output), 0);
 
-	ret = job_process_run (job, PROCESS_POST_START);
-	TEST_EQ (ret, 0);
+	job_process_start (job, PROCESS_POST_START);
+	TEST_WATCH_UPDATE ();
 
 	pid = job->pid[PROCESS_POST_START];
 	TEST_GT (pid, 0);
@@ -9159,7 +9118,7 @@
 void
 run_tests (void)
 {
-	test_run ();
+	test_start ();
 	test_spawn ();
 	test_log_path ();
 	test_kill ();

=== modified file 'test/test_util_common.h'
--- test/test_util_common.h	2014-05-08 11:44:11 +0000
+++ test/test_util_common.h	2014-05-21 22:55:26 +0000
@@ -88,6 +88,41 @@
 }
 
 /**
+ * TEST_WATCH_LOOP:
+ * 
+ * Loop for NihIo object Updates, and process them until no watches
+ * left.
+ */
+#define TEST_WATCH_LOOP()                                            \
+{							             \
+	/* Loop until we've fed all of the data. */                  \
+	int first = TRUE;                                            \
+	for (;;) {                                                   \
+		fd_set readfds, writefds, exceptfds;                 \
+		int    nfds;					     \
+								     \
+		nfds = 0;					     \
+		FD_ZERO (&readfds);				     \
+		FD_ZERO (&writefds);				     \
+		FD_ZERO (&exceptfds);				     \
+								     \
+		nih_io_select_fds (&nfds, &readfds,		     \
+				   &writefds, &exceptfds);	     \
+		if (! nfds) {					     \
+		    if (first)					     \
+			TEST_FAILED ("expected to have "	     \
+				     "data to feed.");		     \
+		    break;					     \
+		}						     \
+		first = FALSE;					     \
+									\
+		select (nfds, &readfds, &writefds, &exceptfds, NULL);	\
+								     \
+		nih_io_handle_fds (&readfds, &writefds, &exceptfds); \
+	}							     \
+}
+
+/**
  * _TEST_WATCH_UPDATE:
  * @force: if TRUE, force an update,
  * @timeout: struct timeval pointer, or NULL if no timeout required.