/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char *argv[])
{
int first = 1;
int opt_char;
int option_index;
uid_t some_uid;
long tmp_l;
static struct option long_options[] = {
{"primary_slurmctld_failure", no_argument, 0, 'a'},
{"primary_slurmctld_resumed_operation", no_argument, 0, 'A'},
{"primary_slurmctld_resumed_control", no_argument, 0, 'b'},
{"backup_slurmctld_failure", no_argument, 0, 'B'},
{"backup_slurmctld_resumed_operation", no_argument, 0, 'c'},
{"backup_slurmctld_assumed_control", no_argument, 0, 'C'},
{"down", no_argument, 0, 'd'},
{"drained", no_argument, 0, 'D'},
{"primary_slurmctld_acct_buffer_full", no_argument, 0, 'e'},
{"fini", no_argument, 0, 'f'},
{"fail", no_argument, 0, 'F'},
{"primary_slurmdbd_failure", no_argument, 0, 'g'},
{"primary_slurmdbd_resumed_operation", no_argument, 0, 'G'},
{"primary_database_failure", no_argument, 0, 'h'},
{"primary_database_resumed_operation", no_argument, 0, 'H'},
{"id", required_argument, 0, 'i'},
{"idle", no_argument, 0, 'I'},
{"jobid", required_argument, 0, 'j'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"node", optional_argument, 0, 'n'},
{"offset", required_argument, 0, 'o'},
{"program", required_argument, 0, 'p'},
{"quiet", no_argument, 0, 'Q'},
{"reconfig", no_argument, 0, 'r'},
{"time", no_argument, 0, 't'},
{"up", no_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"block_err", no_argument, 0, OPT_LONG_BLOCK_ERR},
{"clear", no_argument, 0, OPT_LONG_CLEAR},
{"flags", required_argument, 0, OPT_LONG_FLAGS},
{"front_end", no_argument, 0, OPT_LONG_FRONT_END},
{"get", no_argument, 0, OPT_LONG_GET},
{"help", no_argument, 0, OPT_LONG_HELP},
{"set", no_argument, 0, OPT_LONG_SET},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"user", required_argument, 0, OPT_LONG_USER},
{NULL, 0, 0, 0}
};
_init_options();
optind = 0;
while ((opt_char = getopt_long(argc, argv,
"aAbBcCdDeFfgGhHi:Ij:M:n::o:p:QrtuvV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
if (first) {
first = 0;
fprintf(stderr, "Try \"strigger --help\" for "
"more information\n");
}
exit(1);
break;
case (int)'a':
params.pri_ctld_fail = true;
break;
case (int)'A':
params.pri_ctld_res_op = true;
break;
case (int)'b':
params.pri_ctld_res_ctrl = true;
break;
case (int)'B':
params.bu_ctld_fail = true;
break;
case (int)'c':
params.bu_ctld_res_op = true;
break;
case (int)'C':
params.bu_ctld_as_ctrl = true;
break;
case (int)'d':
params.node_down = true;
break;
case (int)'D':
params.node_drained = true;
break;
case (int)'e':
params.pri_ctld_acct_buffer_full = true;
break;
case (int)'f':
params.job_fini = true;
break;
case (int)'F':
params.node_fail = true;
break;
case (int)'g':
params.pri_dbd_fail = true;
break;
case (int)'G':
params.pri_dbd_res_op = true;
break;
case (int)'h':
params.pri_db_fail = true;
break;
case (int)'H':
params.pri_db_res_op = true;
break;
case (int)'i':
params.trigger_id = atoi(optarg);
break;
case (int)'I':
params.node_idle = true;
break;
case (int)'j':
tmp_l = atol(optarg);
if (tmp_l <= 0) {
error("Invalid jobid %s", optarg);
exit(1);
}
params.job_id = tmp_l;
break;
case (int) 'M':
if (params.clusters)
list_destroy(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"--cluster. Use 'sacctmgr --list "
"cluster' to see available clusters.",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case (int)'n':
xfree(params.node_id);
if (optarg)
params.node_id = xstrdup(optarg);
else
params.node_id = xstrdup("*");
break;
case (int)'o':
params.offset = atoi(optarg);
break;
case (int)'p':
xfree(params.program);
params.program = xstrdup(optarg);
break;
case (int)'Q':
params.quiet = true;
break;
case (int)'r':
params.reconfig = true;
break;
case (int)'t':
params.time_limit = true;
break;
case (int)'u':
params.node_up = true;
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version();
exit(0);
case (int) OPT_LONG_BLOCK_ERR:
params.block_err = true;
break;
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
case (int) OPT_LONG_CLEAR:
params.mode_clear = true;
break;
case (int) OPT_LONG_FLAGS:
if (!strncasecmp(optarg, "perm", 4))
params.flags = TRIGGER_FLAG_PERM;
else {
error("Invalid flags %s", optarg);
exit(1);
}
break;
case (int) OPT_LONG_FRONT_END:
params.front_end = true;
break;
case (int) OPT_LONG_GET:
params.mode_get = true;
break;
case (int) OPT_LONG_SET:
params.mode_set = true;
break;
case (int) OPT_LONG_USER:
if ( uid_from_string( optarg, &some_uid ) != 0 ) {
error("Invalid user %s", optarg);
exit(1);
}
params.user_id = (uint32_t) some_uid;
break;
}
}
if (params.verbose)
_print_options();
_validate_options();
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char *argv[])
{
char *env_val = NULL;
int opt_char;
int option_index;
hostlist_t host_list;
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"bg", no_argument, 0, 'b'},
{"dead", no_argument, 0, 'd'},
{"exact", no_argument, 0, 'e'},
{"noheader", no_argument, 0, 'h'},
{"iterate", required_argument, 0, 'i'},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"nodes", required_argument, 0, 'n'},
{"Node", no_argument, 0, 'N'},
{"format", required_argument, 0, 'o'},
{"partition", required_argument, 0, 'p'},
{"responding",no_argument, 0, 'r'},
{"list-reasons", no_argument, 0, 'R'},
{"summarize", no_argument, 0, 's'},
{"sort", required_argument, 0, 'S'},
{"states", required_argument, 0, 't'},
{"reservation",no_argument, 0, 'T'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"hide", no_argument, 0, OPT_LONG_HIDE},
{NULL, 0, 0, 0}
};
if (getenv("SINFO_ALL"))
params.all_flag = true;
if ( ( env_val = getenv("SINFO_PARTITION") ) ) {
params.partition = xstrdup(env_val);
params.all_flag = true;
}
if ( ( env_val = getenv("SINFO_SORT") ) )
params.sort = xstrdup(env_val);
if ( ( env_val = getenv("SLURM_CLUSTERS") ) ) {
if (!(params.clusters = slurmdb_get_info_cluster(env_val))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"SLURM_CLUSTERS. Use 'sacctmgr --list "
"cluster' to see available clusters.",
env_val);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
}
while((opt_char = getopt_long(argc, argv, "abdehi:lM:n:No:p:rRsS:t:TvV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"sinfo --help\" for more information\n");
exit(1);
break;
case (int)'a':
params.all_flag = true;
break;
case (int)'b':
params.cluster_flags = slurmdb_setup_cluster_flags();
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.bg_flag = true;
else {
error("Must be on a BG system to use --bg "
"option, if using --cluster option "
"put the --bg option "
"after the --cluster option.");
exit(1);
}
break;
case (int)'d':
params.dead_nodes = true;
break;
case (int)'e':
params.exact_match = true;
break;
case (int)'h':
params.no_header = true;
break;
case (int) 'i':
params.iterate= atoi(optarg);
if (params.iterate <= 0) {
error ("Error: invalid entry for "
"--iterate=%s", optarg);
exit(1);
}
break;
case (int) 'l':
params.long_output = true;
break;
case (int) 'M':
if (params.clusters)
list_destroy(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"--cluster. Use 'sacctmgr --list "
"cluster' to see available clusters.",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case (int) 'n':
xfree(params.nodes);
params.nodes = xstrdup(optarg);
/*
* confirm valid nodelist entry
*/
host_list = hostlist_create(params.nodes);
if (!host_list) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
if (hostlist_count(host_list) == 1)
params.node_name_single = true;
else
params.node_name_single = false;
hostlist_destroy(host_list);
break;
case (int) 'N':
params.node_flag = true;
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'p':
xfree(params.partition);
params.partition = xstrdup(optarg);
params.all_flag = true;
break;
case (int) 'r':
params.responding_nodes = true;
break;
case (int) 'R':
params.list_reasons = true;
break;
case (int) 's':
params.summarize = true;
break;
case (int) 'S':
xfree(params.sort);
params.sort = xstrdup(optarg);
break;
case (int) 't':
xfree(params.states);
params.states = xstrdup(optarg);
if (!(params.state_list = _build_state_list(optarg))) {
error ("valid states: %s", _node_state_list ());
exit (1);
}
break;
case (int) 'T':
params.reservation_flag = true;
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version ();
exit(0);
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
case OPT_LONG_HIDE:
params.all_flag = false;
break;
}
}
params.cluster_flags = slurmdb_setup_cluster_flags();
if ( params.format == NULL ) {
if ( params.summarize ) {
params.part_field_flag = true; /* compute size later */
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.format = "%9P %.5a %.10l %.32F %N";
else
params.format = "%9P %.5a %.10l %.16F %N";
} else if ( params.node_flag ) {
params.node_field_flag = true; /* compute size later */
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%N %.6D %.9P %.11T %.4c %.8z %.6m %.8d %.6w %.8f %20E" :
"%N %.6D %.9P %6t";
} else if (params.list_reasons) {
params.format = params.long_output ?
"%20E %12U %19H %6t %N" :
"%20E %9u %19H %N";
} else if ((env_val = getenv ("SINFO_FORMAT"))) {
params.format = xstrdup(env_val);
} else {
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%9P %.5a %.10l %.10s %.4r %.5h %.10g %.6D %.11T %N" :
"%9P %.5a %.10l %.6D %.6t %N";
}
}
_parse_format( params.format );
if (params.list_reasons && (params.state_list == NULL)) {
params.states = xstrdup ("down,drain,error");
if (!(params.state_list = _build_state_list (params.states)))
fatal ("Unable to build state list for -R!");
}
if (params.dead_nodes || params.nodes || params.partition ||
params.responding_nodes ||params.state_list)
params.filtering = true;
if (params.verbose)
_print_options();
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char **argv)
{
char *env_val = NULL;
int opt_char;
int option_index;
hostlist_t host_list;
bool long_form = false;
bool opt_a_set = false, opt_p_set = false;
bool env_a_set = false, env_p_set = false;
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"bg", no_argument, 0, 'b'},
{"dead", no_argument, 0, 'd'},
{"exact", no_argument, 0, 'e'},
{"federation",no_argument, 0, OPT_LONG_FEDR},
{"help", no_argument, 0, OPT_LONG_HELP},
{"hide", no_argument, 0, OPT_LONG_HIDE},
{"iterate", required_argument, 0, 'i'},
{"local", no_argument, 0, OPT_LONG_LOCAL},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"nodes", required_argument, 0, 'n'},
{"noconvert", no_argument, 0, OPT_LONG_NOCONVERT},
{"noheader", no_argument, 0, 'h'},
{"Node", no_argument, 0, 'N'},
{"format", required_argument, 0, 'o'},
{"Format", required_argument, 0, 'O'},
{"partition", required_argument, 0, 'p'},
{"responding",no_argument, 0, 'r'},
{"list-reasons", no_argument, 0, 'R'},
{"summarize", no_argument, 0, 's'},
{"sort", required_argument, 0, 'S'},
{"states", required_argument, 0, 't'},
{"reservation",no_argument, 0, 'T'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{NULL, 0, 0, 0}
};
params.convert_flags = CONVERT_NUM_UNIT_EXACT;
if (slurmctld_conf.fed_params &&
strstr(slurmctld_conf.fed_params, "fed_display"))
params.federation_flag = true;
if (getenv("SINFO_ALL")) {
env_a_set = true;
params.all_flag = true;
}
if (getenv("SINFO_FEDERATION"))
params.federation_flag = true;
if (getenv("SINFO_LOCAL"))
params.local = true;
if ( ( env_val = getenv("SINFO_PARTITION") ) ) {
env_p_set = true;
params.partition = xstrdup(env_val);
params.part_list = _build_part_list(env_val);
params.all_flag = true;
}
if (env_a_set && env_p_set) {
error("Conflicting options, SINFO_ALL and SINFO_PARTITION, specified. "
"Please choose one or the other.");
exit(1);
}
if ( ( env_val = getenv("SINFO_SORT") ) )
params.sort = xstrdup(env_val);
if ( ( env_val = getenv("SLURM_CLUSTERS") ) ) {
if (!(params.clusters = slurmdb_get_info_cluster(env_val))) {
print_db_notok(env_val, 1);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
params.local = true;
}
while ((opt_char = getopt_long(argc, argv,
"abdehi:lM:n:No:O:p:rRsS:t:TvV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"sinfo --help\" for more information\n");
exit(1);
break;
case (int)'a':
opt_a_set = true;
xfree(params.partition);
FREE_NULL_LIST(params.part_list);
params.all_flag = true;
break;
case (int)'b':
params.cluster_flags = slurmdb_setup_cluster_flags();
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.bg_flag = true;
else {
error("Must be on a BG system to use --bg "
"option, if using --cluster option "
"put the --bg option "
"after the --cluster option.");
exit(1);
}
break;
case (int)'d':
params.dead_nodes = true;
break;
case (int)'e':
params.exact_match = true;
break;
case (int)'h':
params.no_header = true;
break;
case (int) 'i':
params.iterate= atoi(optarg);
if (params.iterate <= 0) {
error ("Error: invalid entry for "
"--iterate=%s", optarg);
exit(1);
}
break;
case (int) 'l':
params.long_output = true;
break;
case (int) 'M':
FREE_NULL_LIST(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
print_db_notok(optarg, 0);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
params.local = true;
break;
case OPT_LONG_NOCONVERT:
params.convert_flags |= CONVERT_NUM_UNIT_NO;
break;
case (int) 'n':
xfree(params.nodes);
params.nodes = xstrdup(optarg);
/*
* confirm valid nodelist entry
*/
host_list = hostlist_create(params.nodes);
if (!host_list) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
if (hostlist_count(host_list) == 1) {
params.node_name_single = true;
xfree(params.nodes);
params.nodes =
hostlist_deranged_string_xmalloc(host_list);
} else
params.node_name_single = false;
hostlist_destroy(host_list);
break;
case (int) 'N':
params.node_flag = true;
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'O':
long_form = true;
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'p':
opt_p_set = true;
xfree(params.partition);
FREE_NULL_LIST(params.part_list);
params.partition = xstrdup(optarg);
params.part_list = _build_part_list(optarg);
params.all_flag = true;
break;
case (int) 'r':
params.responding_nodes = true;
break;
case (int) 'R':
params.list_reasons = true;
break;
case (int) 's':
params.summarize = true;
break;
case (int) 'S':
xfree(params.sort);
params.sort = xstrdup(optarg);
break;
case (int) 't':
xfree(params.states);
params.states = xstrdup(optarg);
if (!(params.state_list = _build_state_list(optarg))) {
error ("valid states: %s", _node_state_list ());
exit (1);
}
break;
case (int) 'T':
params.reservation_flag = true;
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version ();
exit(0);
case (int) OPT_LONG_FEDR:
params.federation_flag = true;
break;
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
case OPT_LONG_HIDE:
params.all_flag = false;
break;
case OPT_LONG_LOCAL:
params.local = true;
break;
}
}
if (opt_a_set && opt_p_set) {
error("Conflicting options, -a and -p, specified. "
"Please choose one or the other.");
exit(1);
}
params.cluster_flags = slurmdb_setup_cluster_flags();
if (params.federation_flag && !params.clusters && !params.local) {
void *ptr = NULL;
char *cluster_name = slurm_get_cluster_name();
if (slurm_load_federation(&ptr) ||
!cluster_in_federation(ptr, cluster_name)) {
/* Not in federation */
params.local = true;
slurm_destroy_federation_rec(ptr);
} else {
params.fed = (slurmdb_federation_rec_t *) ptr;
}
xfree(cluster_name);
}
if ( params.format == NULL ) {
if ( params.summarize ) {
params.part_field_flag = true; /* compute size later */
if (params.cluster_flags & CLUSTER_FLAG_BG)
params.format = "%9P %.5a %.10l %.32F %N";
else
params.format = "%9P %.5a %.10l %.16F %N";
} else if ( params.node_flag ) {
params.node_field_flag = true; /* compute size later */
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%N %.6D %.9P %.11T %.4c %.8z %.6m %.8d %.6w %.8f %20E" :
"%N %.6D %.9P %6t";
} else if (params.list_reasons) {
params.format = params.long_output ?
"%20E %12U %19H %6t %N" :
"%20E %9u %19H %N";
} else if ((env_val = getenv ("SINFO_FORMAT"))) {
params.format = xstrdup(env_val);
} else if (params.fed) {
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%9P %8V %.5a %.10l %.10s %.4r %.8h %.10g %.6D %.11T %N" :
"%9P %8V %.5a %.10l %.6D %.6t %N";
} else {
params.part_field_flag = true; /* compute size later */
params.format = params.long_output ?
"%9P %.5a %.10l %.10s %.4r %.8h %.10g %.6D %.11T %N" :
"%9P %.5a %.10l %.6D %.6t %N";
}
}
if (long_form)
_parse_long_format(params.format);
else
_parse_format(params.format);
if (params.list_reasons && (params.state_list == NULL)) {
params.states = xstrdup ("down,drain,error");
if (!(params.state_list = _build_state_list (params.states)))
fatal ("Unable to build state list for -R!");
}
if (params.dead_nodes || params.nodes || params.partition ||
params.responding_nodes ||params.state_list)
params.filtering = true;
if (params.verbose)
_print_options();
}
/*
* parse_command_line
*/
extern void
parse_command_line( int argc, char* *argv )
{
int opt_char;
int option_index;
static struct option long_options[] = {
{"noheader", no_argument, 0, 'h'},
{"jobs", optional_argument, 0, 'j'},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"norm", no_argument, 0, 'n'},
{"format", required_argument, 0, 'o'},
{"user", required_argument, 0, 'u'},
{"users", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"weights", no_argument, 0, 'w'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{NULL, 0, 0, 0}
};
/* get defaults from environment */
_opt_env();
while((opt_char = getopt_long(argc, argv, "hj::lM:no:u:vVw",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"sprio --help\" "
"for more information\n");
exit(1);
case (int)'h':
params.no_header = true;
break;
case (int) 'j':
if (optarg) {
params.jobs = xstrdup(optarg);
params.job_list = _build_job_list(params.jobs);
}
params.job_flag = true;
break;
case (int) 'l':
params.long_list = true;
break;
case (int) 'M':
FREE_NULL_LIST(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
print_db_notok(optarg, 0);
exit(1);
}
break;
case (int) 'n':
params.normalized = true;
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
break;
case (int) 'u':
xfree(params.users);
params.users = xstrdup(optarg);
params.user_list = _build_user_list(params.users);
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version ();
exit(0);
case (int) 'w':
params.weights = true;
break;
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if (optind < argc) {
if (params.job_flag) {
params.jobs = xstrdup(argv[optind++]);
params.job_list = _build_job_list(params.jobs);
}
if (optind < argc) {
error("Unrecognized option: %s",argv[optind]);
_usage();
exit(1);
}
}
if (params.verbose)
_print_options();
if (params.clusters) {
if (list_count(params.clusters) > 1) {
fatal("Only one cluster can be used at a time with "
"sprio");
}
working_cluster_rec = list_peek(params.clusters);
}
}
/*
* parse_command_line
*/
extern void
parse_command_line( int argc, char* argv[] )
{
char *env_val = NULL;
bool override_format_env = false;
int opt_char;
int option_index;
static struct option long_options[] = {
{"accounts", required_argument, 0, 'A'},
{"all", no_argument, 0, 'a'},
{"format", required_argument, 0, 'o'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"hide", no_argument, 0, OPT_LONG_HIDE},
{"iterate", required_argument, 0, 'i'},
{"jobs", optional_argument, 0, 'j'},
{"long", no_argument, 0, 'l'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"node", required_argument, 0, 'n'},
{"nodes", required_argument, 0, 'n'},
{"noheader", no_argument, 0, 'h'},
{"partitions", required_argument, 0, 'p'},
{"qos", required_argument, 0, 'q'},
{"reservation",required_argument, 0, 'R'},
{"sort", required_argument, 0, 'S'},
{"start", no_argument, 0, OPT_LONG_START},
{"steps", optional_argument, 0, 's'},
{"states", required_argument, 0, 't'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"user", required_argument, 0, 'u'},
{"users", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{NULL, 0, 0, 0}
};
if (getenv("SQUEUE_ALL"))
params.all_flag = true;
if ( ( env_val = getenv("SQUEUE_SORT") ) )
params.sort = xstrdup(env_val);
if ( ( env_val = getenv("SLURM_CLUSTERS") ) ) {
if (!(params.clusters = slurmdb_get_info_cluster(env_val))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"SLURM_CLUSTERS. Use 'sacctmgr --list "
"cluster' to see avaliable clusters.",
env_val);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
}
while ((opt_char = getopt_long(argc, argv,
"A:ahi:j::ln:M:o:p:q:R:s::S:t:u:U:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"squeue --help\" "
"for more information\n");
exit(1);
case (int) 'A':
case (int) 'U': /* backwards compatibility */
xfree(params.accounts);
params.accounts = xstrdup(optarg);
params.account_list =
_build_str_list( params.accounts );
break;
case (int)'a':
params.all_flag = true;
break;
case (int)'h':
params.no_header = true;
break;
case (int) 'i':
params.iterate= atoi(optarg);
if (params.iterate <= 0) {
error ("--iterate=%s\n", optarg);
exit(1);
}
break;
case (int) 'j':
if (optarg) {
params.jobs = xstrdup(optarg);
params.job_list =
_build_job_list(params.jobs);
}
params.job_flag = true;
break;
case (int) 'l':
params.long_list = true;
override_format_env = true;
break;
case (int) 'M':
if (params.clusters)
list_destroy(params.clusters);
if (!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' can't be reached now, "
"or it is an invalid entry for "
"--cluster. Use 'sacctmgr --list "
"cluster' to see avaliable clusters.",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case (int) 'n':
if (params.nodes)
hostset_destroy(params.nodes);
params.nodes = hostset_create(optarg);
if (params.nodes == NULL) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
break;
case (int) 'o':
xfree(params.format);
params.format = xstrdup(optarg);
override_format_env = true;
break;
case (int) 'p':
xfree(params.partitions);
params.partitions = xstrdup(optarg);
params.part_list =
_build_str_list( params.partitions );
params.all_flag = true;
break;
case (int) 'q':
xfree(params.qoss);
params.qoss = xstrdup(optarg);
params.qos_list =
_build_str_list( params.qoss );
break;
case (int) 'R':
xfree(params.reservation);
params.reservation = xstrdup(optarg);
break;
case (int) 's':
if (optarg) {
params.steps = xstrdup(optarg);
params.step_list =
_build_step_list(params.steps);
}
params.step_flag = true;
override_format_env = true;
break;
case (int) 'S':
xfree(params.sort);
params.sort = xstrdup(optarg);
break;
case (int) 't':
xfree(params.states);
params.states = xstrdup(optarg);
params.state_list =
_build_state_list( params.states );
break;
case (int) 'u':
xfree(params.users);
params.users = xstrdup(optarg);
params.user_list =
_build_user_list( params.users );
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version();
exit(0);
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_HIDE:
params.all_flag = false;
break;
case OPT_LONG_START:
params.start_flag = true;
break;
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if ( override_format_env == false ) {
if ( ( env_val = getenv("SQUEUE_FORMAT") ) )
params.format = xstrdup(env_val);
}
params.cluster_flags = slurmdb_setup_cluster_flags();
if (optind < argc) {
if (params.job_flag) {
params.jobs = xstrdup(argv[optind++]);
params.job_list = _build_job_list(params.jobs);
} else if (params.step_flag) {
params.steps = xstrdup(argv[optind++]);
params.step_list = _build_step_list(params.steps);
}
if (optind < argc) {
error("Unrecognized option: %s",argv[optind]);
_usage();
exit(1);
}
}
if ( params.job_flag && params.step_flag) {
if (params.job_list) {
verbose("Printing job steps with job filter");
params.job_flag = false;
} else {
error("Incompatible options --jobs and --steps");
exit(1);
}
}
if ( params.nodes ) {
char *name1 = NULL;
char *name2 = NULL;
hostset_t nodenames = hostset_create(NULL);
if (nodenames == NULL)
fatal("malloc failure");
while ( hostset_count(params.nodes) > 0 ) {
name1 = hostset_pop(params.nodes);
/* localhost = use current host name */
if ( strcasecmp("localhost", name1) == 0 ) {
name2 = xmalloc(128);
gethostname_short(name2, 128);
} else {
/* translate NodeHostName to NodeName */
name2 = slurm_conf_get_nodename(name1);
/* use NodeName if translation failed */
if ( name2 == NULL )
name2 = xstrdup(name1);
}
hostset_insert(nodenames, name2);
free(name1);
xfree(name2);
}
/* Replace params.nodename with the new one */
hostset_destroy(params.nodes);
params.nodes = nodenames;
}
if ( ( params.accounts == NULL ) &&
( env_val = getenv("SQUEUE_ACCOUNT") ) ) {
params.accounts = xstrdup(env_val);
params.account_list = _build_str_list( params.accounts );
}
if ( ( params.partitions == NULL ) &&
( env_val = getenv("SQUEUE_PARTITION") ) ) {
params.partitions = xstrdup(env_val);
params.part_list = _build_str_list( params.partitions );
params.all_flag = true;
}
if ( ( params.qoss == NULL ) &&
( env_val = getenv("SQUEUE_QOS") ) ) {
params.qoss = xstrdup(env_val);
params.qos_list = _build_str_list( params.qoss );
}
if ( ( params.states == NULL ) &&
( env_val = getenv("SQUEUE_STATES") ) ) {
params.states = xstrdup(env_val);
params.state_list = _build_state_list( params.states );
}
if ( ( params.users == NULL ) &&
( env_val = getenv("SQUEUE_USERS") ) ) {
params.users = xstrdup(env_val);
params.user_list = _build_user_list( params.users );
}
if ( params.start_flag && !params.step_flag ) {
/* Set more defaults */
if (params.format == NULL)
params.format = xstrdup("%.7i %.9P %.8j %.8u %.2t %.19S %.6D %R");
if (params.sort == NULL)
params.sort = xstrdup("S");
if (params.states == NULL) {
params.states = xstrdup("PD");
params.state_list = _build_state_list( params.states );
}
}
params.max_cpus = _max_cpus_per_node();
if ( params.verbose )
_print_options();
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char **argv)
{
char *sbcast_parameters;
char *end_ptr = NULL, *env_val = NULL, *sep, *tmp;
int opt_char;
int option_index;
static struct option long_options[] = {
{"compress", optional_argument, 0, 'C'},
{"fanout", required_argument, 0, 'F'},
{"force", no_argument, 0, 'f'},
{"jobid", required_argument, 0, 'j'},
{"preserve", no_argument, 0, 'p'},
{"size", required_argument, 0, 's'},
{"timeout", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{NULL, 0, 0, 0}
};
if ((sbcast_parameters = slurm_get_sbcast_parameters()) &&
(tmp = strcasestr(sbcast_parameters, "Compression="))) {
tmp += 12;
sep = strchr(tmp, ',');
if (sep)
sep[0] = '\0';
params.compress = parse_compress_type(tmp);
if (sep)
sep[0] = ',';
}
if ((env_val = getenv("SBCAST_COMPRESS")))
params.compress = parse_compress_type(env_val);
if ( ( env_val = getenv("SBCAST_FANOUT") ) )
params.fanout = atoi(env_val);
if (getenv("SBCAST_FORCE"))
params.force = true;
params.job_id = NO_VAL;
params.pack_job_offset = NO_VAL;
params.step_id = NO_VAL;
if (getenv("SBCAST_PRESERVE"))
params.preserve = true;
if ( ( env_val = getenv("SBCAST_SIZE") ) )
params.block_size = _map_size(env_val);
else
params.block_size = 8 * 1024 * 1024;
if ( ( env_val = getenv("SBCAST_TIMEOUT") ) )
params.timeout = (atoi(env_val) * 1000);
optind = 0;
while ((opt_char = getopt_long(argc, argv, "CfF:j:ps:t:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"sbcast --help\" for more information\n");
exit(1);
break;
case (int)'C':
params.compress = parse_compress_type(optarg);
break;
case (int)'f':
params.force = true;
break;
case (int)'F':
params.fanout = atoi(optarg);
break;
case (int)'j':
params.job_id = strtol(optarg, &end_ptr, 10);
if (end_ptr[0] == '+') {
params.pack_job_offset =
strtol(end_ptr+1, &end_ptr, 10);
}
if (end_ptr[0] == '.')
params.step_id = strtol(end_ptr+1, NULL, 10);
break;
case (int)'p':
params.preserve = true;
break;
case (int) 's':
params.block_size = _map_size(optarg);
break;
case (int)'t':
params.timeout = (atoi(optarg) * 1000);
break;
case (int) 'v':
params.verbose++;
break;
case (int) 'V':
print_slurm_version();
exit(0);
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if ((argc - optind) != 2) {
fprintf(stderr, "Need two file names, have %d names\n",
(argc - optind));
fprintf(stderr, "Try \"sbcast --help\" for more information\n");
exit(1);
}
if (params.job_id == NO_VAL) {
if (!(env_val = getenv("SLURM_JOB_ID"))) {
error("Need a job id to run this command. "
"Run from within a Slurm job or use the "
"--jobid option.");
exit(1);
}
params.job_id = strtol(env_val, &end_ptr, 10);
if (end_ptr[0] == '.')
params.step_id = strtol(end_ptr+1, NULL, 10);
}
params.src_fname = xstrdup(argv[optind]);
if (argv[optind+1][0] == '/') {
params.dst_fname = xstrdup(argv[optind+1]);
} else if (sbcast_parameters &&
(tmp = strcasestr(sbcast_parameters, "DestDir="))) {
tmp += 8;
sep = strchr(tmp, ',');
if (sep)
sep[0] = '\0';
xstrfmtcat(params.dst_fname, "%s/%s", tmp, argv[optind+1]);
if (sep)
sep[0] = ',';
} else {
#ifdef HAVE_GET_CURRENT_DIR_NAME
tmp = get_current_dir_name();
#else
tmp = malloc(PATH_MAX);
tmp = getcwd(tmp, PATH_MAX);
#endif
xstrfmtcat(params.dst_fname, "%s/%s", tmp, argv[optind+1]);
free(tmp);
}
xfree(sbcast_parameters);
if (params.verbose)
_print_options();
}
