int mod_main (flux_t h, int argc, char **argv)
{
int saved_errno;
ctx_t *ctx = getctx (h);
if (!ctx) {
saved_errno = errno;
flux_log_error (h, "error allocating context");
goto error;
}
if (flux_msg_handler_addvec (h, htab, ctx) < 0) {
saved_errno = errno;
flux_log_error (h, "flux_msg_handler_addvec");
goto error;
}
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
saved_errno = errno;
flux_log_error (h, "flux_reactor_run");
flux_msg_handler_delvec (htab);
goto error;
}
flux_msg_handler_delvec (htab);
return 0;
error:
errno = saved_errno;
return -1;
}
int mod_main (flux_t *h, int argc, char **argv)
{
ctx_t *ctx = getctx (h);
uint32_t rank;
flux_msg_handler_t **handlers = NULL;
int rc = -1;
if (flux_get_rank (h, &rank) < 0)
return -1;
if (rank != 0) {
flux_log (h, LOG_ERR, "this module must only run on rank 0");
return -1;
}
flux_log (h, LOG_INFO, "module starting");
if (flux_event_subscribe (h, "sim.start") < 0) {
flux_log (h, LOG_ERR, "subscribing to event: %s", strerror (errno));
return -1;
}
if (flux_msg_handler_addvec (h, htab, ctx, &handlers) < 0) {
flux_log (h, LOG_ERR, "flux_msg_handler_add: %s", strerror (errno));
return -1;
}
send_alive_request (h, module_name);
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log (h, LOG_ERR, "flux_reactor_run: %s", strerror (errno));
goto done_delvec;
}
rc = 0;
done_delvec:
flux_msg_handler_delvec (handlers);
return rc;
}
int mod_main (flux_t *h, int argc, char **argv)
{
flux_msg_handler_t **handlers = NULL;
sqlite_ctx_t *ctx = getctx (h);
if (!ctx)
goto done;
if (flux_event_subscribe (h, "shutdown") < 0) {
flux_log_error (h, "flux_event_subscribe");
goto done;
}
if (flux_msg_handler_addvec (h, htab, ctx, &handlers) < 0) {
flux_log_error (h, "flux_msg_handler_addvec");
goto done;
}
if (register_backing_store (h, true, "content-sqlite") < 0) {
flux_log_error (h, "registering backing store");
goto done;
}
if (register_content_backing_service (h) < 0) {
flux_log_error (h, "service.add: content-backing");
goto done;
}
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log_error (h, "flux_reactor_run");
goto done;
}
done:
flux_msg_handler_delvec (handlers);
return 0;
}
int mod_main (flux_t *h, int argc, char **argv)
{
int saved_errno;
flux_msg_handler_t **handlers = NULL;
if (argc == 1 && !strcmp (argv[0], "--init-failure")) {
flux_log (h, LOG_INFO, "aborting during init per test request");
errno = EIO;
goto error;
}
if (!(modules = zhash_new ())) {
errno = ENOMEM;
goto error;
}
if (flux_get_rank (h, &rank) < 0)
goto error;
if (flux_msg_handler_addvec (h, htab, NULL, &handlers) < 0)
goto error;
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log_error (h, "flux_reactor_run");
goto error;
}
zhash_destroy (&modules);
return 0;
error:
saved_errno = errno;
flux_msg_handler_delvec (handlers);
zhash_destroy (&modules);
errno = saved_errno;
return -1;
}
int publisher_set_flux (struct publisher *pub, flux_t *h)
{
pub->h = h;
if (flux_msg_handler_addvec (h, htab, pub, &pub->handlers) < 0)
return -1;
return 0;
}
int mod_main (flux_t *h, int argc, char **argv)
{
int rc = -1;
ctx_t *ctx = getctx (h);
if (!ctx)
goto done;
if (flux_event_subscribe (h, "barrier.") < 0) {
flux_log_error (h, "flux_event_subscribe");
goto done;
}
if (flux_msg_handler_addvec (h, htab, ctx) < 0) {
flux_log_error (h, "flux_msghandler_add");
goto done;
}
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log_error (h, "flux_reactor_run");
goto done_unreg;
}
rc = 0;
done_unreg:
flux_msg_handler_delvec (htab);
done:
return rc;
}
struct alloc_ctx *alloc_ctx_create (flux_t *h, struct queue *queue,
struct event_ctx *event_ctx)
{
struct alloc_ctx *ctx;
flux_reactor_t *r = flux_get_reactor (h);
if (!(ctx = calloc (1, sizeof (*ctx))))
return NULL;
ctx->h = h;
ctx->queue = queue;
ctx->event_ctx = event_ctx;
if (!(ctx->inqueue = queue_create (false)))
goto error;
if (flux_msg_handler_addvec (h, htab, ctx, &ctx->handlers) < 0)
goto error;
ctx->prep = flux_prepare_watcher_create (r, prep_cb, ctx);
ctx->check = flux_check_watcher_create (r, check_cb, ctx);
ctx->idle = flux_idle_watcher_create (r, NULL, NULL);
if (!ctx->prep || !ctx->check || !ctx->idle) {
errno = ENOMEM;
goto error;
}
flux_watcher_start (ctx->prep);
flux_watcher_start (ctx->check);
event_ctx_set_alloc_ctx (event_ctx, ctx);
return ctx;
error:
alloc_ctx_destroy (ctx);
return NULL;
}
int heaptrace_initialize (flux_t *h)
{
char *dummy = "hello";
if (flux_msg_handler_addvec (h, htab, NULL, &handlers) < 0)
return -1;
flux_aux_set (h, "flux::heaptrace", dummy, heaptrace_finalize);
return 0;
}
int mod_main (flux_t *h, int argc, char **argv)
{
zhash_t *args = zhash_fromargv (argc, argv);
ctx_t *ctx;
char *eoc_str;
bool exit_on_complete;
uint32_t rank;
if (flux_get_rank (h, &rank) < 0)
return -1;
if (rank != 0) {
flux_log (h, LOG_ERR, "sim module must only run on rank 0");
return -1;
}
flux_log (h, LOG_INFO, "sim comms module starting");
if (!(eoc_str = zhash_lookup (args, "exit-on-complete"))) {
flux_log (h,
LOG_ERR,
"exit-on-complete argument is not set, defaulting to false");
exit_on_complete = false;
} else {
exit_on_complete =
(!strcmp (eoc_str, "true") || !strcmp (eoc_str, "True"));
}
ctx = getctx (h, exit_on_complete);
if (flux_event_subscribe (h, "rdl.update") < 0) {
flux_log (h, LOG_ERR, "subscribing to event: %s", strerror (errno));
return -1;
}
if (flux_msg_handler_addvec (h, htab, ctx) < 0) {
flux_log (h, LOG_ERR, "flux_msg_handler_add: %s", strerror (errno));
return -1;
}
if (send_start_event (h) < 0) {
flux_log (h, LOG_ERR, "sim failed to send start event");
return -1;
}
flux_log (h, LOG_DEBUG, "sim sent start event");
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log (h, LOG_ERR, "flux_reactor_run: %s", strerror (errno));
return -1;
}
return 0;
}
struct sched_plugin_loader *sched_plugin_loader_create (flux_t *h)
{
struct sched_plugin_loader *sploader = malloc (sizeof (*sploader));
if (!sploader) {
errno = ENOMEM;
return NULL;
}
memset (sploader, 0, sizeof (*sploader));
sploader->h = h;
if (flux_msg_handler_addvec (h, plugin_htab, sploader) < 0) {
flux_log_error (h, "flux_msghandler_addvec");
free (sploader);
return NULL;
}
return sploader;
}
static int notify_status_obj (flux_t *h, jsc_handler_obj_f func, void *d)
{
int rc = -1;
cb_pair_t *c = NULL;
jscctx_t *ctx = NULL;
flux_msg_handler_t **handlers;
if (!func)
goto done;
if (flux_event_subscribe (h, "wreck.state.") < 0) {
flux_log_error (h, "subscribing to job event");
rc = -1;
goto done;
}
if (flux_event_subscribe (h, "jsc.state.") < 0) {
flux_log_error (h, "subscribing to job event");
rc = -1;
goto done;
}
if (flux_msg_handler_addvec (h, htab, NULL, &handlers) < 0) {
flux_log_error (h, "registering resource event handler");
rc = -1;
goto done;
}
ctx = getctx (h);
ctx->handlers = handlers;
c = (cb_pair_t *) xzmalloc (sizeof(*c));
c->cb = func;
c->arg = d;
if (zlist_append (ctx->callbacks, c) < 0)
goto done;
zlist_freefn (ctx->callbacks, c, free, true);
rc = 0;
done:
return rc;
}
int main (int argc, char *argv[])
{
flux_msg_t *msg;
flux_t *h;
flux_reactor_t *reactor;
plan (NO_PLAN);
(void)setenv ("FLUX_CONNECTOR_PATH",
flux_conf_get ("connector_path", CONF_FLAG_INTREE), 0);
ok ((h = flux_open ("loop://", FLUX_O_COPROC)) != NULL,
"opened loop connector");
if (!h)
BAIL_OUT ("can't continue without loop handle");
flux_fatal_set (h, fatal_err, NULL);
ok ((reactor = flux_get_reactor(h)) != NULL,
"obtained reactor");
if (!h)
BAIL_OUT ("can't continue without reactor");
ok (flux_msg_handler_addvec (h, htab, NULL) == 0,
"registered message handlers");
/* test continues in rpctest_begin_cb() so that rpc calls
* can sleep while we answer them
*/
ok ((msg = flux_request_encode ("rpctest.begin", NULL)) != NULL,
"encoded rpctest.begin request OK");
ok (flux_send (h, msg, 0) == 0,
"sent rpctest.begin request");
ok (flux_reactor_run (reactor, 0) == 0,
"reactor completed normally");
flux_msg_destroy (msg);
/* test _then: Slightly tricky.
* Send request. We're not in a coproc ctx here in main(), so there
* will be no response, therefore, check will be false. Register
* continuation, start reactor. Response will be received, continuation
* will be invoked. Continuation stops the reactor.
*/
flux_rpc_t *r;
ok ((r = flux_rpc (h, "rpctest.echo", "{}", FLUX_NODEID_ANY, 0)) != NULL,
"flux_rpc with payload when payload is expected works");
ok (flux_rpc_check (r) == false,
"flux_rpc_check says get would block");
/* reg/unreg _then a couple times for fun */
ok (flux_rpc_then (r, NULL, 0) == 0,
"flux_rpc_then with NULL cb works");
ok (flux_rpc_then (r, then_cb, h) == 0,
"flux_rpc_then works after NULL");
ok (flux_rpc_then (r, NULL, 0) == 0,
"flux_rpc_then with NULL cb after non-NULL works");
ok (flux_rpc_then (r, then_cb, h) == 0,
"flux_rpc_then works");
/* enough of that */
ok (flux_reactor_run (reactor, 0) == 0,
"reactor completed normally");
flux_rpc_destroy (r);
/* Test a _then corner case:
* If _check() is called before _then(), a message may have been cached
* in the flux_rpc_t. rpctest_thenbug_cb creates this condition.
* Next, _then continuation is installed, but will reactor call it?
* This will hang if rpc implementation doesn't return a cached message
* back to the handle in _then(). Else, continuation will stop reactor.
*/
ok ((thenbug_r = flux_rpc (h, "rpctest.echo", "{}",
FLUX_NODEID_ANY, 0)) != NULL,
"thenbug: sent echo request");
do {
if (!(msg = flux_request_encode ("rpctest.thenbug", NULL))
|| flux_send (h, msg, 0) < 0
|| flux_reactor_run (reactor, 0) < 0) {
flux_msg_destroy (msg);
break;
}
flux_msg_destroy (msg);
} while (!flux_rpc_check (thenbug_r));
ok (true,
"thenbug: check says message ready");
ok (flux_rpc_then (thenbug_r, then_cb, h) == 0,
"thenbug: registered then - hangs on failure");
ok (flux_reactor_run (reactor, 0) == 0,
"reactor completed normally");
flux_rpc_destroy (thenbug_r);
flux_msg_handler_delvec (htab);
flux_close (h);
done_testing();
return (0);
}
