int kvs_conf_save (flux_t h, flux_conf_t cf)
{
flux_conf_itr_t itr = flux_conf_itr_create (cf);
const char *key;
int rc = -1;
if (kvs_unlink (h, kvs_conf_root) < 0)
goto done;
if (kvs_commit (h) < 0)
goto done;
while ((key = flux_conf_next (itr))) {
char *nkey = xasprintf ("%s.%s", kvs_conf_root, key);
const char *val = flux_conf_get (cf, key);
int n = kvs_put_string (h, nkey, val);
free (nkey);
if (n < 0)
goto done;
}
if (kvs_commit (h) < 0)
goto done;
rc = 0;
done:
flux_conf_itr_destroy (itr);
return rc;
}
int main (int argc, char *argv[])
{
flux_t *h;
plan (NO_PLAN);
(void)setenv ("FLUX_CONNECTOR_PATH",
flux_conf_get ("connector_path", CONF_FLAG_INTREE), 0);
ok ((h = flux_open ("loop://", 0)) != NULL,
"opened loop connector");
if (!h)
BAIL_OUT ("can't continue without loop handle");
flux_attr_set_cacheonly (h, "rank", "0");
flux_attr_set_cacheonly (h, "tbon.level", "0");
flux_attr_set_cacheonly (h, "tbon.maxlevel", "0");
test_nopolicy (h); // 6
test_hwm (h); // 37
test_timed(h); // 18
flux_close (h);
done_testing();
return (0);
}
void config_get (flux_conf_t cf, int ac, char **av)
{
const char *val;
if (ac != 1)
msg_exit ("get accepts one argument");
val = flux_conf_get (cf, av[0]);
if (!val)
err_exit ("%s", av[0]);
printf ("%s\n", val);
}
void config_dump (flux_conf_t cf, int ac, char **av)
{
flux_conf_itr_t itr;
const char *key, *val;
if (ac > 0)
msg_exit ("dump accepts no arguments");
itr = flux_conf_itr_create (cf);
while ((key = flux_conf_next (itr))) {
if (!(val = flux_conf_get (cf, key)))
err_exit ("%s", key);
printf("%s=%s\n", key, val);
}
flux_conf_itr_destroy (itr);
}
void test_helpers (void)
{
char *name, *path;
const char *modpath = flux_conf_get ("module_path", CONF_FLAG_INTREE);
path = xasprintf ("%s/kvs/.libs/kvs.so", modpath);
ok (access (path, F_OK) == 0,
"built kvs module is located");
name = flux_modname (path);
ok ((name != NULL),
"flux_modname on kvs should find a name");
skip (name == NULL, 1,
"skip next test because kvs.so name is NULL");
like (name, "^kvs$",
"flux_modname says kvs module is named kvs");
end_skip;
if (name)
free (name);
free (path);
ok (!flux_modfind ("nowhere", "foo"),
"flux_modfind fails with nonexistent directory");
ok (!flux_modfind (".", "foo"),
"flux_modfind fails in current directory");
ok (!flux_modfind (modpath, "foo"),
"flux_modfind fails to find unknown module in moduledir");
path = xasprintf ("%s/kvs/.libs", modpath);
name = flux_modfind (path, "kvs");
ok ((name != NULL),
"flux_modfind finds kvs in flat directory");
if (name)
free (name);
free (path);
name = flux_modfind (modpath, "kvs");
ok ((name != NULL),
"flux_modfind also finds kvs in moduledir");
if (name)
free (name);
path = xasprintf ("foo:bar:xyz:%s:zzz", modpath);
name = flux_modfind (path, "kvs");
ok ((name != NULL),
"flux_modfind also finds kvs in search path");
if (name)
free (name);
free (path);
}
void setup_keydir (struct environment *env, int flags)
{
const char *dir = getenv ("FLUX_SEC_DIRECTORY");
char *new_dir = NULL;
if (!dir)
dir = flux_conf_get ("keydir", flags);
if (!dir) {
struct passwd *pw = getpwuid (getuid ());
if (!pw)
log_msg_exit ("Who are you!?!");
dir = new_dir = xasprintf ("%s/.flux", pw->pw_dir);
}
if (!dir)
log_msg_exit ("Could not determine keydir");
environment_set (env, "FLUX_SEC_DIRECTORY", dir, 0);
if (new_dir)
free (new_dir);
}
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);
}
int main (int argc, char **argv)
{
flux_t h;
heartbeat_t *hb;
flux_msg_handler_t *w;
plan (18);
check_codec ();
(void)setenv ("FLUX_CONNECTOR_PATH",
flux_conf_get ("connector_path", CONF_FLAG_INTREE), 0);
ok ((h = flux_open ("loop://", 0)) != NULL,
"opened loop connector");
if (!h)
BAIL_OUT ("can't continue without loop handle");
flux_fatal_set (h, fatal_err, NULL);
ok ((hb = heartbeat_create ()) != NULL,
"heartbeat_create works");
heartbeat_set_flux (hb, h);
ok (heartbeat_get_rate (hb) == 2.,
"heartbeat_get_rate returns default of 2s");
errno = 0;
ok (heartbeat_set_rate (hb, -1) < 1 && errno == EINVAL,
"heartbeat_set_rate -1 fails with EINVAL");
errno = 0;
ok (heartbeat_set_rate (hb, 1000000) < 1 && errno == EINVAL,
"heartbeat_set_rate 1000000 fails with EINVAL");
ok (heartbeat_set_ratestr (hb, "250ms") == 0,
"heartbeat_set_ratestr 250ms works");
ok (heartbeat_get_rate (hb) == 0.250,
"heartbeat_get_rate returns what was set");
ok (heartbeat_set_rate (hb, 0.1) == 0,
"heartbeat_set_rate 0.1 works");
ok (heartbeat_get_rate (hb) == 0.1,
"heartbeat_get_rate returns what was set");
ok (heartbeat_get_epoch (hb) == 0,
"heartbeat_get_epoch works, default is zero");
w = flux_msg_handler_create (h, FLUX_MATCH_EVENT, heartbeat_event_cb, hb);
ok (w != NULL,
"created event watcher");
flux_msg_handler_start (w);
ok (heartbeat_start (hb) == 0,
"heartbeat_start works");
ok (flux_reactor_run (flux_get_reactor (h), 0) == 0,
"flux reactor exited normally");
heartbeat_destroy (hb);
flux_msg_handler_destroy (w);
flux_close (h);
done_testing ();
return 0;
}
flux_t *flux_open (const char *uri, int flags)
{
char *default_uri = NULL;
char *path = NULL;
char *scheme = NULL;
void *dso = NULL;
connector_init_f *connector_init = NULL;
const char *s;
flux_t *h = NULL;
if (!uri)
uri = getenv ("FLUX_URI");
if (!uri) {
if (asprintf (&default_uri, "local://%s",
flux_conf_get ("rundir", 0)) < 0)
goto done;
uri = default_uri;
}
if (!(scheme = strdup (uri))) {
errno = ENOMEM;
goto done;
}
path = strstr (scheme, "://");
if (path) {
*path = '\0';
path = strtrim (path + 3, " \t");
}
if (!(connector_init = find_connector (scheme, &dso)))
goto done;
if (getenv ("FLUX_HANDLE_TRACE"))
flags |= FLUX_O_TRACE;
if (getenv ("FLUX_HANDLE_MATCHDEBUG"))
flags |= FLUX_O_MATCHDEBUG;
if (!(h = connector_init (path, flags))) {
dlclose (dso);
goto done;
}
h->dso = dso;
#if HAVE_CALIPER
profiling_context_init(&h->prof);
#endif
if ((s = getenv ("FLUX_HANDLE_USERID"))) {
uint32_t userid = strtoul (s, NULL, 10);
if (flux_opt_set (h, FLUX_OPT_TESTING_USERID, &userid,
sizeof (userid)) < 0) {
flux_handle_destroy (h);
h = NULL;
goto done;
}
}
if ((s = getenv ("FLUX_HANDLE_ROLEMASK"))) {
uint32_t rolemask = strtoul (s, NULL, 0);
if (flux_opt_set (h, FLUX_OPT_TESTING_ROLEMASK, &rolemask,
sizeof (rolemask)) < 0) {
flux_handle_destroy (h);
h = NULL;
goto done;
}
}
done:
free (scheme);
free (default_uri);
return h;
}
static optparse_t * setup_optparse_parse_args (int argc, char *argv[])
{
optparse_err_t e;
struct optparse_option helpopt = {
.name = "help", .key = 'h', .usage = "Display this message"
};
optparse_t *p = optparse_create ("flux");
if (p == NULL)
log_err_exit ("optparse_create");
optparse_set (p, OPTPARSE_USAGE, "[OPTIONS] COMMAND ARGS");
e = optparse_add_option_table (p, opts);
if (e != OPTPARSE_SUCCESS)
log_msg_exit ("optparse_add_option_table() failed");
// Remove automatic `--help' in favor of our own usage() from above
e = optparse_remove_option (p, "help");
if (e != OPTPARSE_SUCCESS)
log_msg_exit ("optparse_remove_option (\"help\")");
e = optparse_add_option (p, &helpopt);
if (e != OPTPARSE_SUCCESS)
log_msg_exit ("optparse_add_option (\"help\")");
// Don't print internal subcommands in --help (we print subcommands using
// emit_command_help() above.
e = optparse_set (p, OPTPARSE_PRINT_SUBCMDS, 0);
if (e != OPTPARSE_SUCCESS)
log_msg_exit ("optparse_set (OPTPARSE_PRINT_SUBCMDS");
register_builtin_subcommands (p);
if (optparse_parse_args (p, argc, argv) < 0)
exit (1);
return (p);
}
int main (int argc, char *argv[])
{
bool vopt = false;
struct environment *env;
optparse_t *p;
const char *searchpath;
const char *argv0 = argv[0];
int flags = 0;
log_init ("flux");
p = setup_optparse_parse_args (argc, argv);
if (!flux_is_installed ())
flags |= CONF_FLAG_INTREE;
optparse_set_data (p, "conf_flags", &flags);
if (optparse_hasopt (p, "help")) {
usage (p); // N.B. accesses "conf_flags"
exit (0);
}
optind = optparse_optind (p);
if (argc - optind == 0) {
usage (p);
exit (1);
}
vopt = optparse_hasopt (p, "verbose");
/* prepare the environment 'env' that will be passed to subcommands.
*/
env = environment_create ();
/* Add PATH to env and prepend path to this executable if necessary.
*/
setup_path (env, argv0);
/* Prepend config values to env values.
* Note special handling of lua ;; (default path).
*/
environment_from_env (env, "LUA_CPATH", "", ';');
environment_no_dedup_push_back (env, "LUA_CPATH", ";;");
environment_push (env, "LUA_CPATH", flux_conf_get ("lua_cpath_add", flags));
environment_push (env, "LUA_CPATH", getenv ("FLUX_LUA_CPATH_PREPEND"));
environment_from_env (env, "LUA_PATH", "", ';');
environment_no_dedup_push_back (env, "LUA_PATH", ";;");
environment_push (env, "LUA_PATH", flux_conf_get ("lua_path_add", flags));
environment_push (env, "LUA_PATH", getenv ("FLUX_LUA_PATH_PREPEND"));
environment_from_env (env, "PYTHONPATH", "", ':');
environment_push (env, "PYTHONPATH", flux_conf_get ("python_path", flags));
environment_push (env, "PYTHONPATH", getenv ("FLUX_PYTHONPATH_PREPEND"));
environment_from_env (env, "MANPATH", "", ':');
environment_push (env, "MANPATH", flux_conf_get ("man_path", flags));
environment_from_env (env, "FLUX_EXEC_PATH", "", ':');
environment_push (env, "FLUX_EXEC_PATH",
flux_conf_get ("exec_path", flags));
environment_push (env, "FLUX_EXEC_PATH", getenv ("FLUX_EXEC_PATH_PREPEND"));
environment_from_env (env, "FLUX_CONNECTOR_PATH", "", ':');
environment_push (env, "FLUX_CONNECTOR_PATH",
flux_conf_get ("connector_path", flags));
environment_push (env, "FLUX_CONNECTOR_PATH",
getenv ("FLUX_CONNECTOR_PATH_PREPEND"));
environment_from_env (env, "FLUX_MODULE_PATH", "", ':');
environment_push (env, "FLUX_MODULE_PATH",
flux_conf_get ("module_path", flags));
environment_push (env, "FLUX_MODULE_PATH",
getenv ("FLUX_MODULE_PATH_PREPEND"));
/* Set FLUX_SEC_DIRECTORY, possibly to $HOME/.flux.
*/
setup_keydir (env, flags);
if (getenv ("FLUX_URI"))
environment_from_env (env, "FLUX_URI", "", 0); /* pass-thru */
environment_from_env (env, "FLUX_RC1_PATH",
flux_conf_get ("rc1_path", flags), 0);
environment_from_env (env, "FLUX_RC3_PATH",
flux_conf_get ("rc3_path", flags), 0);
environment_from_env (env, "FLUX_PMI_LIBRARY_PATH",
flux_conf_get ("pmi_library_path", flags), 0);
environment_from_env (env, "FLUX_WRECK_LUA_PATTERN",
flux_conf_get ("wreck_lua_pattern", flags), 0);
environment_from_env (env, "FLUX_WREXECD_PATH",
flux_conf_get ("wrexecd_path", flags), 0);
environment_apply(env);
optparse_set_data (p, "env", env);
if (vopt)
print_environment (env);
if (optparse_get_subcommand (p, argv [optind])) {
if (optparse_run_subcommand (p, argc, argv) < 0)
exit (1);
} else {
searchpath = environment_get (env, "FLUX_EXEC_PATH");
if (vopt)
printf ("sub-command search path: %s\n", searchpath);
exec_subcommand (searchpath, vopt, argv + optind);
}
environment_destroy (env);
optparse_destroy (p);
log_fini ();
return 0;
}
static const char *default_cmdhelp_pattern (optparse_t *p)
{
int *flags = optparse_get_data (p, "conf_flags");
return flux_conf_get ("cmdhelp_pattern", *flags);
}
