void *server_thread (void *arg)
{
struct context *ctx = arg;
flux_reactor_t *reactor = NULL;
flux_watcher_t *w = NULL;
if (!(reactor = flux_reactor_create (0)))
goto done;
if (!(w = flux_fd_watcher_create (reactor, ctx->fds[1],
FLUX_POLLIN, s_io_cb, ctx)))
goto done;
flux_watcher_start (w);
ctx->exit_rc = -1;
if (flux_reactor_run (reactor, 0) < 0)
goto done;
ctx->exit_rc = 0;
done:
if (w)
flux_watcher_destroy (w);
if (reactor)
flux_reactor_destroy (reactor);
return NULL;
}
static void reactor_destroy_early (void)
{
flux_reactor_t *r;
flux_watcher_t *w;
if (!(r = flux_reactor_create ()))
exit (1);
if (!(w = flux_idle_watcher_create (r, NULL, NULL)))
exit (1);
flux_watcher_start (w);
flux_reactor_destroy (r);
flux_watcher_destroy (w);
}
flux_reactor_t *flux_reactor_create (int flags)
{
flux_reactor_t *r = xzmalloc (sizeof (*r));
if ((flags & FLUX_REACTOR_SIGCHLD))
r->loop = ev_default_loop (EVFLAG_SIGNALFD);
else
r->loop = ev_loop_new (EVFLAG_NOSIGMASK);
if (!r->loop) {
errno = ENOMEM;
flux_reactor_destroy (r);
return NULL;
}
ev_set_userdata (r->loop, r);
r->usecount = 1;
return r;
}
int main (int ac, char **av)
{
int rc;
struct subprocess_manager *sm;
struct subprocess *p;
flux_reactor_t *r;
zsys_handler_set (NULL);
plan (NO_PLAN);
if (!(sm = subprocess_manager_create ()))
BAIL_OUT ("Failed to create subprocess manager");
ok (sm != NULL, "create subprocess manager");
if (!(r = flux_reactor_create (FLUX_REACTOR_SIGCHLD)))
BAIL_OUT ("Failed to create a reactor");
rc = subprocess_manager_set (sm, SM_REACTOR, r);
ok (rc == 0, "set subprocess manager reactor (rc=%d, %s)", rc, strerror (errno));
if (!(p = subprocess_create (sm)))
BAIL_OUT ("Failed to create a subprocess object");
ok (subprocess_set_callback (p, exit_handler, r) >= 0,
"set subprocess exit handler");
ok (subprocess_set_io_callback (p, io_cb) >= 0,
"set subprocess io callback");
ok (subprocess_set_command (p, "sleep 0.5 && /bin/echo -n 'hello\nworld\n'") >= 0,
"set subprocess command");
ok (subprocess_set_environ (p, environ) >= 0,
"set subprocess environ");
ok (subprocess_fork (p) >= 0, "subprocess_fork");
ok (subprocess_exec (p) >= 0, "subprocess_exec");
ok (flux_reactor_run (r, 0) == 0,
"reactor returned normally");
subprocess_manager_destroy (sm);
flux_reactor_destroy (r);
done_testing ();
}
int main (int argc, char **argv)
{
zio_t *zio;
int init_fds;
const char *name;
struct counts c;
int fd;
flux_reactor_t *r;
flux_watcher_t *w;
memset (&c, 0, sizeof (c));
plan (NO_PLAN);
test_encode ();
ok ((r = flux_reactor_create (0)) != NULL,
"flux reactor created");
init_fds = fdcount ();
diag ("initial fd count: %d", init_fds);
/* simple reader tests
*/
ok ((zio = zio_pipe_reader_create ("test1", &c)) != NULL,
"reader: zio_pipe_reader_create works");
ok ((name = zio_name (zio)) != NULL && !strcmp (name, "test1"),
"reader: zio_name returns correct name");
ok (zio_set_close_cb (zio, close_reader) == 0,
"reader: zio_set_close_cb works");
ok (zio_set_send_cb (zio, send_reader) == 0,
"reader: zio_set_send_cb works");
ok (zio_reactor_attach (zio, r) == 0,
"reader: zio_reactor_attach works");
ok ((fd = zio_dst_fd (zio)) >= 0,
"reader: zio_dst_fd returned valid file descriptor");
ok (write (fd, "narf!", 5) == 5,
"reader: wrote narf! to reader pipe");
ok (zio_close_dst_fd (zio) == 0,
"reader: zio_close_dst_fd succeeded");
ok (flux_reactor_run (r, 0) == 0,
"reader: reactor completed successfully");
ok (c.send_reader == 1,
"reader: send function called once for EOF + incomplete line");
errno = 0;
zio_destroy (zio);
ok (init_fds == fdcount (),
"reader: zio_destroy leaks no file descriptors");
/* simple writer tests
*/
ok ((zio = zio_pipe_writer_create ("test2", &c)) != NULL,
"writer: zio_pipe_writer_create works");
ok ((name = zio_name (zio)) != NULL && !strcmp (name, "test2"),
"writer: zio_name returns correct name");
ok (zio_set_close_cb (zio, close_writer) == 0,
"writer: zio_set_close_cb works");
ok ((fd = zio_src_fd (zio)) >= 0,
"writer: zio_src_fd returned valid file descriptor");
w = flux_fd_watcher_create (r, fd, FLUX_POLLIN, fd_read, &c);
ok (w != NULL,
"writer: created fd watcher");
flux_watcher_start (w);
ok (zio_write (zio, "narf!", 5) == 5,
"writer: zio_write narf! works");
ok (zio_write_eof (zio) == 0,
"writer: zio_write_eof works");
ok (flux_reactor_run (r, 0) == 0,
"writer: reactor completed successfully");
ok (c.fd_read_errors == 0 && c.fd_read_data == 5 && c.fd_read_eof == 1,
"writer: read narf + EOF on read end of pipe");
ok (c.close_writer == 1,
"writer: close callback invoked");
zio_destroy (zio);
ok (init_fds == fdcount (),
"writer: zio_destroy leaks no file descriptors");
flux_watcher_destroy (w);
flux_reactor_destroy (r);
done_testing ();
}
