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) { 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 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; }
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; }
void sched_plugin_loader_destroy (struct sched_plugin_loader *sploader) { if (sploader) { sched_plugin_unload (sploader); flux_msg_handler_delvec (plugin_htab); free (sploader); } }
static void freectx (void *arg) { jscctx_t *ctx = arg; zhash_destroy (&(ctx->active_jobs)); lru_cache_destroy (ctx->kvs_paths); zlist_destroy (&(ctx->callbacks)); flux_msg_handler_delvec (ctx->handlers); }
void alloc_ctx_destroy (struct alloc_ctx *ctx) { if (ctx) { int saved_errno = errno;; flux_msg_handler_delvec (ctx->handlers); flux_watcher_destroy (ctx->prep); flux_watcher_destroy (ctx->check); flux_watcher_destroy (ctx->idle); queue_destroy (ctx->inqueue); free (ctx); errno = saved_errno; } }
void publisher_destroy (struct publisher *pub) { if (pub) { int saved_errno = errno; flux_msg_handler_delvec (pub->handlers); if (pub->senders) { struct sender *sender; while ((sender = zlist_pop (pub->senders))) free (sender); zlist_destroy (&pub->senders); } free (pub); errno = saved_errno; } }
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); }
static void heaptrace_finalize (void *arg) { flux_msg_handler_delvec (handlers); }