static int extract_raw_rdl_alloc (flux_t *h, int64_t j, json_object *jcb)
{
int i;
json_object *ra = Jnew_ar ();
bool processing = true;
for (i=0; processing; ++i) {
char *key = lwj_key (h, j, ".rank.%d.cores", i);
flux_future_t *f = NULL;
int64_t cores = 0;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get_unpack (f, "I", &cores) < 0) {
if (errno != EINVAL)
flux_log_error (h, "extract %s", key);
processing = false;
} else {
json_object *elem = Jnew ();
json_object *o = Jnew ();
Jadd_int64 (o, JSC_RDL_ALLOC_CONTAINED_NCORES, cores);
json_object_object_add (elem, JSC_RDL_ALLOC_CONTAINED, o);
json_object_array_add (ra, elem);
}
free (key);
flux_future_destroy (f);
}
json_object_object_add (jcb, JSC_RDL_ALLOC, ra);
return 0;
}
int main (int argc, char *argv[])
{
flux_t *h;
const char *key;
flux_future_t *f;
if (argc != 2) {
fprintf (stderr, "Usage: waitcreate_cancel key\n");
return (1);
}
key = argv[1];
if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
if (!(f = flux_kvs_lookup (h, NULL, FLUX_KVS_WAITCREATE, key)))
log_err_exit ("flux_kvs_lookup");
if (flux_kvs_lookup_cancel (f) < 0)
log_err_exit ("flux_kvs_lookup_cancel");
if (flux_kvs_lookup_get (f, NULL) < 0) {
if (errno != ENODATA)
log_err_exit ("flux_kvs_lookup_get");
flux_future_destroy (f);
}
else
log_msg_exit ("flux_kvs_lookup_get returned success");
flux_close (h);
return (0);
}
static int depthfirst_map_one (flux_t *h, const char *key, int dirskip,
restart_map_f cb, void *arg)
{
flux_jobid_t id;
flux_future_t *f;
const char *eventlog;
struct job *job = NULL;
char path[64];
int rc = -1;
if (strlen (key) <= dirskip) {
errno = EINVAL;
return -1;
}
if (fluid_decode (key + dirskip + 1, &id, FLUID_STRING_DOTHEX) < 0)
return -1;
if (flux_job_kvs_key (path, sizeof (path), id, "eventlog") < 0) {
errno = EINVAL;
return -1;
}
if (!(f = flux_kvs_lookup (h, NULL, 0, path)))
goto done;
if (flux_kvs_lookup_get (f, &eventlog) < 0)
goto done;
if (!(job = job_create_from_eventlog (id, eventlog)))
goto done;
if (cb (job, arg) < 0)
goto done;
rc = 1;
done:
flux_future_destroy (f);
job_decref (job);
return rc;
}
static int update_1pdesc (flux_t *h, flux_kvs_txn_t *txn,
int r, int64_t j, json_object *o,
json_object *ha, json_object *ea)
{
flux_future_t *f = NULL;
int rc = -1;
json_object *d = NULL;
char *key;
const char *json_str;
const char *hn = NULL, *en = NULL;
int64_t pid = 0, hindx = 0, eindx = 0, hrank = 0;
if (!Jget_int64 (o, JSC_PDESC_RANK_PDARRAY_PID, &pid)) return -1;
if (!Jget_int64 (o, JSC_PDESC_RANK_PDARRAY_HINDX, &hindx)) return -1;
if (!Jget_int64 (o, JSC_PDESC_RANK_PDARRAY_EINDX, &eindx)) return -1;
if (!Jget_ar_str (ha, (int)hindx, &hn)) return -1;
if (!Jget_ar_str (ea, (int)eindx, &en)) return -1;
key = lwj_key (h, j, ".%d.procdesc", r);
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get (f, &json_str) < 0
|| !(d = Jfromstr (json_str))) {
flux_log_error (h, "extract %s", key);
goto done;
}
Jadd_str (d, "command", en);
Jadd_int64 (d, "pid", pid);
errno = 0;
if ( (hrank = strtoul (hn, NULL, 10)) && errno != 0) {
flux_log (h, LOG_ERR, "invalid hostname %s", hn);
goto done;
}
Jadd_int64 (d, "nodeid", (int64_t)hrank);
if (flux_kvs_txn_put (txn, 0, key, Jtostr (d)) < 0) {
flux_log_error (h, "put %s", key);
goto done;
}
rc = 0;
done:
flux_future_destroy (f);
free (key);
if (d)
Jput (d);
return rc;
}
static int depthfirst_map (flux_t *h, const char *key,
int dirskip, restart_map_f cb, void *arg)
{
flux_future_t *f;
const flux_kvsdir_t *dir;
flux_kvsitr_t *itr;
const char *name;
int path_level;
int count = 0;
int rc = -1;
path_level = restart_count_char (key + dirskip, '.');
if (!(f = flux_kvs_lookup (h, NULL, FLUX_KVS_READDIR, key)))
return -1;
if (flux_kvs_lookup_get_dir (f, &dir) < 0) {
if (errno == ENOENT && path_level == 0)
rc = 0;
goto done;
}
if (!(itr = flux_kvsitr_create (dir)))
goto done;
while ((name = flux_kvsitr_next (itr))) {
char *nkey;
int n;
if (!flux_kvsdir_isdir (dir, name))
continue;
if (!(nkey = flux_kvsdir_key_at (dir, name)))
goto done_destroyitr;
if (path_level == 3) // orig 'key' = .A.B.C, thus 'nkey' is complete
n = depthfirst_map_one (h, nkey, dirskip, cb, arg);
else
n = depthfirst_map (h, nkey, dirskip, cb, arg);
if (n < 0) {
int saved_errno = errno;
free (nkey);
errno = saved_errno;
goto done_destroyitr;
}
count += n;
free (nkey);
}
rc = count;
done_destroyitr:
flux_kvsitr_destroy (itr);
done:
flux_future_destroy (f);
return rc;
}
static int extract_raw_walltime (flux_t *h, int64_t j, int64_t *walltime)
{
int rc = 0;
char *key = lwj_key (h, j, ".walltime");
flux_future_t *f = NULL;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get_unpack (f, "I", walltime) < 0) {
flux_log_error (h, "extract %s", key);
rc = -1;
}
else
flux_log (h, LOG_DEBUG, "extract %s: %"PRId64"", key, *walltime);
free (key);
flux_future_destroy (f);
return rc;
}
void errors (void)
{
flux_future_t *f;
/* check simple error cases */
errno = 0;
ok (flux_kvs_lookup (NULL, NULL, 0, NULL) == NULL && errno == EINVAL,
"flux_kvs_lookup fails on bad input");
errno = 0;
ok (flux_kvs_lookupat (NULL, 0, NULL, NULL) == NULL && errno == EINVAL,
"flux_kvs_lookupat fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get (NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get_unpack (NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get_unpack fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get_raw (NULL, NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get_raw fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get_key (NULL) == NULL && errno == EINVAL,
"flux_kvs_lookup_get_key future=NULL fails with EINVAL");
errno = 0;
ok (flux_kvs_lookup_cancel (NULL) == -1 && errno == EINVAL,
"flux_kvs_lookup_cancel future=NULL fails with EINVAL");
if (!(f = flux_future_create (NULL, NULL)))
BAIL_OUT ("flux_future_create failed");
errno = 0;
ok (flux_kvs_lookup_get_key (f) == NULL && errno == EINVAL,
"flux_kvs_lookup_get_key future=(wrong type) fails with EINVAL");
errno = 0;
ok (flux_kvs_lookup_cancel (f) == -1 && errno == EINVAL,
"flux_kvs_lookup_cancel future=(wrong type) fails with EINVAL");
flux_future_destroy (f);
}
static int extract_raw_pdesc (flux_t *h, int64_t j, int64_t i, json_object **o)
{
flux_future_t *f = NULL;
const char *json_str;
char *key = lwj_key (h, j, ".%ju.procdesc", i);
int rc = -1;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get (f, &json_str) < 0
|| !(*o = Jfromstr (json_str))) {
flux_log_error (h, "extract %s", key);
goto done;
}
rc = 0;
done:
flux_future_destroy (f);
free (key);
return rc;
}
static int extract_raw_state (flux_t *h, int64_t j, int64_t *s)
{
int rc = 0;
char *key = lwj_key (h, j, ".state");
const char *state;
flux_future_t *f = NULL;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get_unpack (f, "s", &state) < 0) {
flux_log_error (h, "extract %s", key);
rc = -1;
}
else {
*s = jsc_job_state2num (state);
flux_log (h, LOG_DEBUG, "extract %s: %s", key, state);
}
free (key);
flux_future_destroy (f);
return rc;
}
static int extract_raw_rdl (flux_t *h, int64_t j, char **rdlstr)
{
int rc = 0;
char *key = lwj_key (h, j, ".rdl");
const char *s;
flux_future_t *f = NULL;
if (!key || !(f = flux_kvs_lookup (h, 0, key))
|| flux_kvs_lookup_get_unpack (f, "s", &s) < 0) {
flux_log_error (h, "extract %s", key);
rc = -1;
}
else {
*rdlstr = xstrdup (s);
flux_log (h, LOG_DEBUG, "rdl under %s extracted", key);
}
free (key);
flux_future_destroy (f);
return rc;
}
static int jobid_exist (flux_t *h, int64_t j)
{
flux_future_t *f = NULL;
jscctx_t *ctx = getctx (h);
const char *path = jscctx_jobid_path (ctx, j);
int rc = -1;
if (path == NULL)
goto done;
if (!(f = flux_kvs_lookup (h, FLUX_KVS_READDIR, path))
|| flux_kvs_lookup_get_dir (f, NULL) < 0) {
flux_log (h, LOG_DEBUG, "flux_kvs_lookup(%s): %s",
path, flux_strerror (errno));
goto done;
}
rc = 0;
done:
flux_future_destroy (f);
return rc;
}
void errors (void)
{
/* check simple error cases */
errno = 0;
ok (flux_kvs_lookup (NULL, 0, NULL) == NULL && errno == EINVAL,
"flux_kvs_lookup fails on bad input");
errno = 0;
ok (flux_kvs_lookupat (NULL, 0, NULL, NULL) == NULL && errno == EINVAL,
"flux_kvs_lookupat fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get (NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get_unpack (NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get_unpack fails on bad input");
errno = 0;
ok (flux_kvs_lookup_get_raw (NULL, NULL, NULL) < 0 && errno == EINVAL,
"flux_kvs_lookup_get_raw fails on bad input");
}
int main (int argc, char *argv[])
{
flux_t *h;
const char *key;
int i;
if (argc != 2) {
fprintf (stderr, "Usage: watch_cancel_loop key\n");
return (1);
}
key = argv[1];
if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
for (i = 0; i < 1000; i++) {
flux_future_t *f;
log_msg ("loop=%d", i);
if (!(f = flux_kvs_lookup (h, NULL, FLUX_KVS_WATCH
| FLUX_KVS_WAITCREATE, key)))
log_err_exit ("flux_kvs_lookup");
if (flux_kvs_lookup_cancel (f) < 0)
log_err_exit ("flux_kvs_lookup_cancel");
/* Consume responses until ENODATA from cancel appears
*/
while (flux_kvs_lookup_get (f, NULL) == 0)
;
if (errno != ENODATA)
log_err_exit ("flux_kvs_lookup_get");
flux_future_destroy (f);
}
flux_close (h);
return (0);
}
int main (int argc, char *argv[])
{
flux_t *h;
flux_reactor_t *r;
int last = -1;
int ch;
flux_future_t *f;
log_init ("commit_order");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 'v': /* --verbose */
verbose = true;
break;
case 'c': /* --count N */
totcount = strtoul (optarg, NULL, 10);
break;
case 'f': /* --fanout N */
max_queue_depth = strtoul (optarg, NULL, 10);
break;
case 'n': /* --namespace=NAME */
if (!(ns = strdup (optarg)))
log_err_exit ("out of memory");
break;
default:
usage ();
break;
}
}
if (optind != argc - 1)
usage ();
key = argv[optind++];
if (totcount < 1 || max_queue_depth < 1)
usage ();
if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
if (!(r = flux_get_reactor (h)))
log_err_exit ("flux_get_reactor");
/* One synchronous put before watch request, so that
* watch request doesn't fail with ENOENT.
*/
f = commit_int (h, key, txcount++);
commit_continuation (f, NULL); // destroys f, increments rxcount
/* Configure watcher
* Wait for one response before unleashing async puts, to ensure
* that first value is captured.
*/
if (!(f = flux_kvs_lookup (h, ns, FLUX_KVS_WATCH, key)))
log_err_exit ("flux_kvs_lookup");
watch_continuation (f, &last); // resets f, increments wrxcount
if (flux_future_then (f, -1., watch_continuation, &last) < 0)
log_err_exit ("flux_future_then");
/* Configure mechanism to keep max_queue_depth (--fanout) put RPCs
* outstanding until totcount (--count) reached.
*/
if (!(w_prep = flux_prepare_watcher_create (r, prep, NULL)))
log_err_exit ("flux_prepare_watcher_create");
if (!(w_check = flux_check_watcher_create (r, check, h)))
log_err_exit ("flux_check_watcher_create");
if (!(w_idle = flux_idle_watcher_create (r, NULL, NULL)))
log_err_exit ("flux_idle_watcher_create");
flux_watcher_start (w_prep);
flux_watcher_start (w_check);
/* Run until work is exhausted.
*/
if (flux_reactor_run (r, 0) < 0)
log_err_exit ("flux_reactor_run");
flux_watcher_destroy (w_prep);
flux_watcher_destroy (w_check);
flux_watcher_destroy (w_idle);
free (ns);
flux_close (h);
log_fini ();
return 0;
}
