static int cmd_setattr (optparse_t *p, int ac, char *av[]) { int n; const char *name = NULL, *val = NULL; flux_t h; log_init ("flux-setattr"); n = optparse_optind (p); if (optparse_hasopt (p, "expunge") && n == ac - 1) { name = av[n]; } else if (!optparse_hasopt (p, "expunge") && n == ac - 2) { name = av[n]; val = av[n + 1]; } else { optparse_print_usage (p); exit (1); } h = builtin_get_flux_handle (p); if (flux_attr_set (h, name, val) < 0) log_err_exit ("%s", av[1]); flux_close (h); return (0); }
static int internal_content_store (optparse_t *p, int ac, char *av[]) { const uint32_t blob_size_limit = 1048576; /* RFC 10 */ uint8_t *data; int size; flux_t *h; flux_rpc_t *rpc; const char *topic; if (optparse_optind (p) != ac) { optparse_print_usage (p); exit (1); } if ((size = read_all (STDIN_FILENO, &data)) < 0) log_err_exit ("read"); if (!(h = builtin_get_flux_handle (p))) log_err_exit ("flux_open"); if (optparse_hasopt (p, "dry-run")) { int flags; const char *hashfun; if (size > blob_size_limit) log_errn_exit (EFBIG, "content-store"); if (!(hashfun = flux_attr_get (h, "content-hash", &flags))) log_err_exit ("flux_attr_get content-hash"); if (!strcmp (hashfun, "sha1")) { uint8_t hash[SHA1_DIGEST_SIZE]; char hashstr[SHA1_STRING_SIZE]; SHA1_CTX sha1_ctx; SHA1_Init (&sha1_ctx); SHA1_Update (&sha1_ctx, (uint8_t *)data, size); SHA1_Final (&sha1_ctx, hash); sha1_hashtostr (hash, hashstr); printf ("%s\n", hashstr); } else log_msg_exit ("content-store: unsupported hash function: %s", hashfun); } else { const char *blobref; int blobref_size; if (optparse_hasopt (p, "bypass-cache")) topic = "content-backing.store"; else topic = "content.store"; if (!(rpc = flux_rpc_raw (h, topic, data, size, 0, 0))) log_err_exit ("%s", topic); if (flux_rpc_get_raw (rpc, &blobref, &blobref_size) < 0) log_err_exit ("%s", topic); if (!blobref || blobref[blobref_size - 1] != '\0') log_msg_exit ("%s: protocol error", topic); printf ("%s\n", blobref); flux_rpc_destroy (rpc); } flux_close (h); free (data); return (0); }
static int internal_content_load (optparse_t *p, int ac, char *av[]) { int n; const char *blobref; uint8_t *data; int size; flux_t *h; flux_rpc_t *rpc; const char *topic; n = optparse_optind (p); if (n != ac - 1) { optparse_print_usage (p); exit (1); } blobref = av[n]; if (!(h = builtin_get_flux_handle (p))) log_err_exit ("flux_open"); if (optparse_hasopt (p, "bypass-cache")) topic = "content-backing.load"; else topic = "content.load"; if (!(rpc = flux_rpc_raw (h, topic, blobref, strlen (blobref) + 1, 0, 0))) log_err_exit ("%s", topic); if (flux_rpc_get_raw (rpc, &data, &size) < 0) log_err_exit ("%s", topic); if (write_all (STDOUT_FILENO, data, size) < 0) log_err_exit ("write"); flux_rpc_destroy (rpc); flux_close (h); return (0); }
static int cmd_nodeset (optparse_t *p, int ac, char *av[]) { int ix = optparse_option_index (p); int nsc = ac - ix; nodeset_t *nsp, **nsv = nsc > 0 ? xzmalloc (sizeof (nsv[0]) * nsc) : NULL; int i; for (i = 0; i < nsc; i++) if (!(nsv[i] = nodeset_create_string (av[ix + i]))) log_errn_exit (EINVAL, "%s", av[ix + i]); if (optparse_hasopt (p, "intersection")) nsp = nsv_intersection (nsc, nsv); else nsp = nsv_union (nsc, nsv); if (optparse_hasopt (p, "subtract")) { const char *s = optparse_get_str (p, "subtract", ""); nodeset_t *ns = nodeset_create_string (s); if (!ns) log_errn_exit (EINVAL, "%s", s); ns_subtract (nsp, ns); } if (optparse_hasopt (p, "cardinality")) { printf ("%" PRIu32 "\n", nsp ? nodeset_count (nsp) : 0); } else if (nsp) { const char *delim = optparse_get_str (p, "delimiter", "," ); if (optparse_hasopt (p, "expand")) { nodeset_config_ranges (nsp, false); nodeset_config_brackets (nsp, false); } nodeset_config_separator (nsp, delim[0]); if (nodeset_count (nsp) > 0) printf ("%s\n", nodeset_string (nsp)); } if (nsv) { for (i = 0; i < nsc; i++) nodeset_destroy (nsv[i]); free (nsv); } return (0); }
static int cmd_lsattr (optparse_t *p, int ac, char *av[]) { const char *name, *val; flux_t h; if (optparse_optind (p) != ac) optparse_fatal_usage (p, 1, NULL); h = builtin_get_flux_handle (p); name = flux_attr_first (h); while (name) { if (optparse_hasopt (p, "values")) { val = flux_attr_get (h, name, NULL); printf ("%-40s%s\n", name, val ? val : "-"); } else { printf ("%s\n", name); } name = flux_attr_next (h); } flux_close (h); return (0); }
int mod_main (flux_t h, int argc, char **argv) { optparse_t *p = optparse_create ("pymod"); if (optparse_add_option_table (p, opts) != OPTPARSE_SUCCESS) msg_exit ("optparse_add_option_table"); if (optparse_set (p, OPTPARSE_USAGE, usage_msg) != OPTPARSE_SUCCESS) msg_exit ("optparse_set usage"); int option_index = optparse_parse_args (p, argc, argv); if (option_index <= 0 || optparse_hasopt(p, "help") || option_index >= argc){ optparse_print_usage(p); return (option_index < 0); } const char * module_name = argv[option_index]; Py_SetProgramName("pymod"); Py_Initialize(); PyObject *search_path = PySys_GetObject("path"); // Add installation search paths add_if_not_present(search_path, optparse_get_str(p, "path", "")); add_if_not_present(search_path, FLUX_PYTHON_PATH); PySys_SetObject("path", search_path); if(optparse_hasopt(p, "verbose")){ PyObject_Print(search_path, stderr, 0); } flux_log(h, LOG_INFO, "loading python module named: %s", module_name); PyObject *module = PyImport_ImportModule("flux.core"); if(!module){ PyErr_Print(); return EINVAL; } PyObject *mod_main = PyObject_GetAttrString(module, "mod_main_trampoline"); if(mod_main && PyCallable_Check(mod_main)){ //maybe unpack args directly? probably easier to use a dict PyObject *py_args = PyTuple_New(3); PyTuple_SetItem(py_args, 0, PyString_FromString(module_name)); PyTuple_SetItem(py_args, 1, PyLong_FromVoidPtr(h)); //Convert zhash to native python dict, should preserve mods //through switch to argc-style arguments PyObject *arg_list = PyList_New(0); char ** it = argv + option_index; int i; for (i=0; *it; i++, it++){ PyList_Append(arg_list, PyString_FromString(*it)); } PyTuple_SetItem(py_args, 2, arg_list); // Call into trampoline PyObject_CallObject(mod_main, py_args); if(PyErr_Occurred()){ PyErr_Print(); } Py_DECREF(py_args); Py_DECREF(arg_list); } Py_Finalize(); return 0; }
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; }