int CValEdit::edit(){
int key;
bool valid=false;
if(container()){
if(_help){
_help(MessageStatus::SetMessage,*(container()));
}
key=CLineEdit::edit();
if ((key == UP || key == DOWN || key == TAB || key == ENTER)&&_validate){
valid=_validate((char*)_data,*(container()));
while ((key == UP || key == DOWN || key == TAB || key == ENTER)&&!valid){
key=CLineEdit::edit();
valid=_validate((char*)_data,*(container()));
}
}
if(_help){
_help(MessageStatus::ClearMessage,*(container()));
}
}else{
key:CLineEdit::edit();
}
return key;
}
void Cmd::process(int argc, const char *argv[])
{
Cmd::argc = argc;
Cmd::argv = argv;
if (argc < 2) {
_help();
throw Error(NULL);
}
for (int i=1; i < argc; i++) {
const char *arg = argv[i];
if (!strcmp("-h", arg)) {
_help();
}
else {
Cmd::ifile = arg;
}
}
if (Cmd::ifile == NULL) {
throw Error("no input file");
}
}
int
main(int argc, char *argv[])
{
if (!efreet_init())
{
fputs("ERROR: Could not initialize efreet!\n", stderr);
return EXIT_FAILURE;
}
if (argc < 2)
_print_all();
else
{
int i;
for (i = 1; i < argc; i++)
if ((strcmp(argv[i], "-h") == 0) ||
(strcmp(argv[i], "--help") == 0))
{
_help(argv[0]);
goto end;
}
for (i = 1; i < argc; i++)
_print(argv[i]);
}
end:
efreet_shutdown();
return EXIT_SUCCESS;
}
/*
* parse_command_line, fill in params data structure with data
*/
void parse_command_line(int argc, char *argv[])
{
int opt_char;
int option_index;
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"bgblock", required_argument, 0, 'b'},
{"partition", required_argument, 0, 'p'},
{"remove", no_argument, 0, 'r'},
{"wait", no_argument, 0, 'w'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, 'h'},
{"usage", no_argument, 0, 'u'},
{NULL, 0, 0, 0}
};
while ((opt_char =
getopt_long(argc, argv, "ab:hp:ruVw",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int) '?':
fprintf(stderr,
"Try \"sfree --help\" for more information\n");
exit(1);
break;
case (int) 'a':
all_blocks = 1;
break;
case (int) 'b':
case (int) 'p':
if (!block_list)
block_list = list_create(slurm_destroy_char);
slurm_addto_char_list(block_list, optarg);
break;
case (int) 'h':
case (int) OPT_LONG_HELP:
_help();
exit(0);
case (int) 'r':
remove_blocks = 1;
break;
case (int) 'u':
case (int) OPT_LONG_USAGE:
_usage();
exit(0);
case (int) 'V':
print_slurm_version();
exit(0);
case (int) 'w':
wait_full = true;
break;
}
}
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char *argv[])
{
int opt_char;
int option_index;
static struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"help", no_argument, 0, 'h'},
{"reset", no_argument, 0, 'r'},
{"sort-by-id", no_argument, 0, 'i'},
{"sort-by-time",no_argument, 0, 't'},
{"sort-by-time2",no_argument, 0, 'T'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"version", no_argument, 0, 'V'},
{NULL, 0, 0, 0}
};
while ((opt_char = getopt_long(argc, argv, "ahirtTV", long_options,
&option_index)) != -1) {
switch (opt_char) {
case (int)'a':
sdiag_param = STAT_COMMAND_GET;
break;
case (int)'h':
_help();
exit(0);
break;
case (int)'i':
sort_by_id = true;
break;
case (int)'r':
sdiag_param = STAT_COMMAND_RESET;
break;
case (int)'t':
sort_by_time = true;
break;
case (int)'T':
sort_by_time2 = true;
break;
case (int) 'V':
print_slurm_version();
exit(0);
break;
case (int)OPT_LONG_USAGE:
_usage();
exit(0);
break;
}
}
}
void _help(char *name, int type){
switch(type){
case 0:
printf("ImageJs Version %d.%d.%d\n", VERSION_MAJ, VERSION_MIN, VERSION_FIX);
printf("Usage: %s [option] [javascript file] [flags] [args]\n", name);
printf("Options: gif, bmp, webp, pnm, pgf\n");
printf("Flags (optional): -l Prints image as viewable line.\n");
printf(" -i Injects code into an existing image. Needs an image file as argument.\n");
break;
case 1:
printf("The flag \"%s\" is currently not supported for this type of file.\n", name);
break;
case 2:
printf("The flag \"%s\" needs an argument.\n", name);
break;
case 3:
printf("The file %s could not be opened.\n", name);
break;
default:
_help(name, 0);
break;
}
}
// run the menu
void
Menu::run(void)
{
int8_t ret;
uint8_t len, i;
uint8_t argc;
int c;
char *s;
if (_port == NULL) {
// default to main serial port
_port = &Serial;
}
// loop performing commands
for (;; ) {
// run the pre-prompt function, if one is defined
if ((NULL != _ppfunc) && !_ppfunc())
return;
// loop reading characters from the input
len = 0;
_port->printf_P(PSTR("%S] "), FPSTR(_prompt));
for (;; ) {
c = _port->read();
if (-1 == c)
continue;
// carriage return -> process command
if ('\r' == c) {
_inbuf[len] = '\0';
_port->write('\r');
_port->write('\n');
break;
}
// backspace
if ('\b' == c) {
if (len > 0) {
len--;
_port->write('\b');
_port->write(' ');
_port->write('\b');
continue;
}
}
// printable character
if (isprint(c) && (len < (MENU_COMMANDLINE_MAX - 1))) {
_inbuf[len++] = c;
_port->write((char)c);
continue;
}
}
// split the input line into tokens
argc = 0;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= MENU_ARGS_MAX) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if ('\0' == _argv[argc].str)
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
if (_argv[0].str == NULL) {
continue;
}
// populate arguments that have not been specified with "" and 0
// this is safer than NULL in the case where commands may look
// without testing argc
i = argc;
while (i <= MENU_ARGS_MAX) {
_argv[i].str = "";
_argv[i].i = 0;
_argv[i].f = 0;
i++;
}
bool cmd_found = false;
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp_P(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
cmd_found=true;
if (-2 == ret)
return;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp_P(_argv[0].str, PSTR("help")))) {
_help();
cmd_found=true;
} else if (!strcasecmp_P(_argv[0].str, PSTR("exit"))) {
return;
}
}
if (cmd_found==false)
{
_port->println_P(PSTR("Invalid command, type 'help'"));
}
}
}
/*
* parse_command_line, fill in params data structure with data
*/
extern void parse_command_line(int argc, char *argv[])
{
int opt_char;
int option_index;
int tmp = 0;
static struct option long_options[] = {
{"commandline", no_argument, 0, 'c'},
{"display", required_argument, 0, 'D'},
{"noheader", no_argument, 0, 'h'},
{"iterate", required_argument, 0, 'i'},
{"ionodes", required_argument, 0, 'I'},
{"cluster", required_argument, 0, 'M'},
{"clusters",required_argument, 0, 'M'},
{"nodes", required_argument, 0, 'n'},
{"quiet", no_argument, 0, 'Q'},
{"resolve", required_argument, 0, 'R'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"help", no_argument, 0, OPT_LONG_HELP},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"show_hidden", no_argument, 0, 'H'},
{NULL, 0, 0, 0}
};
memset(¶ms, 0, sizeof(params));
while ((opt_char =
getopt_long(argc, argv, "cD:hi:I:Hn:M:QR:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case '?':
fprintf(stderr,
"Try \"smap --help\" for more information\n");
exit(1);
break;
case 'c':
params.commandline = TRUE;
break;
case 'D':
if (!strcmp(optarg, "j"))
tmp = JOBS;
else if (!strcmp(optarg, "s"))
tmp = SLURMPART;
else if (!strcmp(optarg, "b"))
tmp = BGPART;
else if (!strcmp(optarg, "c"))
tmp = COMMANDS;
else if (!strcmp(optarg, "r"))
tmp = RESERVATIONS;
params.display = tmp;
break;
case 'h':
params.no_header = true;
break;
case 'H':
params.all_flag = true;
break;
case 'i':
params.iterate = atoi(optarg);
if (params.iterate <= 0) {
error("Error: --iterate=%s", optarg);
exit(1);
}
break;
case 'I':
/*
* confirm valid ionodelist entry (The 128 is
* a large number here to avoid having to do a
* lot more querying to figure out the correct
* pset size. This number should be large enough.
*/
params.io_bit = bit_alloc(128);
if(bit_unfmt(params.io_bit, optarg) == -1) {
error("'%s' invalid entry for --ionodes",
optarg);
exit(1);
}
break;
case 'M':
if(params.clusters)
list_destroy(params.clusters);
if(!(params.clusters =
slurmdb_get_info_cluster(optarg))) {
error("'%s' invalid entry for --cluster",
optarg);
exit(1);
}
working_cluster_rec = list_peek(params.clusters);
break;
case 'n':
/*
* confirm valid nodelist entry
*/
params.hl = hostlist_create(optarg);
if (!params.hl) {
error("'%s' invalid entry for --nodes",
optarg);
exit(1);
}
break;
case 'Q':
quiet_flag = 1;
break;
case 'R':
params.commandline = TRUE;
params.resolve = xstrdup(optarg);
break;
case 'v':
params.verbose++;
break;
case 'V':
print_slurm_version();
exit(0);
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
params.cluster_dims = slurmdb_setup_cluster_dims();
if (params.cluster_dims > 4)
fatal("smap is unable to support more than four dimensions");
params.cluster_base = hostlist_get_base(params.cluster_dims);
params.cluster_flags = slurmdb_setup_cluster_flags();
}
// run the menu
bool
Menu::_run_command(bool prompt_on_enter)
{
int8_t ret;
uint8_t i;
uint8_t argc;
char *s = NULL;
_input_len = 0;
// split the input line into tokens
argc = 0;
s = NULL;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= _args_max) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if (_argv[argc].str == NULL || '\0' == _argv[argc].str[0])
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
if (_argv[0].str == NULL) {
// we got a blank line, re-display the prompt
if (prompt_on_enter) {
_display_prompt();
}
return false;
}
// populate arguments that have not been specified with "" and 0
// this is safer than NULL in the case where commands may look
// without testing argc
i = argc;
while (i <= _args_max) {
_argv[i].str = "";
_argv[i].i = 0;
_argv[i].f = 0;
i++;
}
bool cmd_found = false;
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
cmd_found=true;
if (-2 == ret)
return true;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp(_argv[0].str, "help"))) {
_help();
cmd_found=true;
} else if (!strcasecmp(_argv[0].str, "exit")) {
// exit the menu
return true;
}
}
if (cmd_found==false)
{
_port->println("Invalid command, type 'help'");
}
return false;
}
/*
* 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);
}
}
static int
usedraft_help (struct mh_whatnow_env *wh, int argc, char **argv, int *status)
{
return _help (usedraft_helptab, argv[0]);
}
/*
* 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 *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();
}
int main(int argc, char *argv[]){
if(argc < 3){
_help(argv[0], 0);
return 1;
}
FILE *in;
FILE *out;
int filesize;
char *buf;
in = fopen(argv[2], "rb");
if(in){
fseek(in, 0, SEEK_END);
filesize = ftell(in);
rewind(in);
buf = (char*)malloc(filesize * sizeof(char));
fread(buf, 1, filesize, in);
fclose(in);
}else{
_help(argv[2], 3);
return 2;
}
char *outbuf;
if(strcmp(argv[1], "bmp") == 0){
if(argc > 3){
if(argc > 4){
FILE *im = fopen(argv[4], "rb");
if(im){
fseek(im, 0, SEEK_END);
int imsize = ftell(im);
rewind(im);
char *imbuf = (char*)malloc(imsize * sizeof(char));
fread(imbuf, 1, imsize, im);
fclose(im);
outbuf = bmp_js_i(buf, filesize, imbuf, imsize);
out = fopen(bmp_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < (filesize + imsize + BMP_JS_HEADER_I); i++){
fprintf(out, "%c", outbuf[i]);
}
free(imbuf);
}else{
_help(argv[4], 3);
return 2;
}
}else if(strcmp(argv[3] , "-i") == 0){
_help(argv[3], 2);
return 2;
}else{
if(strcmp(argv[3], "-l") == 0){
outbuf = bmp_js_l(buf, filesize);
out = fopen(bmp_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + BMP_JS_HEADER_L; i++){
fprintf(out, "%c", outbuf[i]);
}
}else{
_help(argv[3], 1);
return 3;
}
}
}else{
outbuf = bmp_js(buf, filesize);
out = fopen(bmp_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + BMP_JS_HEADER; i++){
fprintf(out, "%c", outbuf[i]);
}
}
}else if(strcmp(argv[1], "gif") == 0){
if(argc > 3){
if(argc > 4){
FILE *im = fopen(argv[4], "rb");
if(im){
fseek(im, 0, SEEK_END);
int imsize = ftell(im);
rewind(im);
char *imbuf = (char*)malloc(imsize * sizeof(char));
fread(imbuf, 1, imsize, im);
fclose(im);
outbuf = gif_js_i(buf, filesize, imbuf, imsize);
out = fopen(gif_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < (filesize + imsize + GIF_JS_HEADER_I); i++){
fprintf(out, "%c", outbuf[i]);
}
free(imbuf);
}else{
_help(argv[4], 3);
return 2;
}
}else if(strcmp(argv[3], "-i") == 0){
_help(argv[3], 2);
return 2;
}else{
_help(argv[3], 1);
return 3;
}
}else{
outbuf = gif_js(buf, filesize);
out = fopen(gif_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + GIF_JS_HEADER; i++){
fprintf(out, "%c", outbuf[i]);
}
}
}else if(strcmp(argv[1], "webp") == 0){
if(argc > 3){
if(argc > 4){
FILE *im = fopen(argv[4], "rb");
if(im){
fseek(im, 0 , SEEK_END);
int imsize = ftell(im);
rewind(im);
char *imbuf = (char*)malloc(imsize + sizeof(char));
fread(imbuf, 1, imsize, im);
fclose(im);
outbuf = webp_js_i(buf, filesize, imbuf, imsize);
out = fopen(webp_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < (filesize + imsize + WEBP_JS_HEADER_I); i++){
fprintf(out, "%c", outbuf[i]);
}
free(imbuf);
}else{
_help(argv[4], 3);
return 3;
}
}else if(strcmp(argv[3], "-i") == 0){
_help(argv[3], 2);
return 2;
}else{
_help(argv[3], 1);
return 3;
}
}else{
outbuf = webp_js(buf, filesize);
out = fopen(webp_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + WEBP_JS_HEADER; i++){
fprintf(out, "%c", outbuf[i]);
}
}
}else if(strcmp(argv[1], "pnm") == 0){
if(argc > 3){
_help(argv[3], 1);
return 3;
}else{
outbuf = pnm_js(buf, filesize);
out = fopen(pnm_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + PNM_JS_HEADER; i++){
fprintf(out, "%c", outbuf[i]);
}
}
}else if(strcmp(argv[1], "pgf") == 0){
if(argc > 3){
_help(argv[3], 1);
return 3;
}else{
outbuf = pgf_js(buf, filesize);
out = fopen(pgf_filename(argv[2], getlen(argv[2])), "wb");
for(int i = 0; i < filesize + PGF_JS_HEADER; i++){
fprintf(out, "%c", outbuf[i]);
}
}
}else{
_help(argv[0], 0);
free(buf);
return 1;
}
fclose(out);
free(buf);
free(outbuf);
return 0;
}
void set_options(const int argc, char **argv)
{
int opt_char, option_index = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"label", no_argument, 0, 'l'},
{"quiet", no_argument, 0, 'Q'},
{"usage", no_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"layout", no_argument, 0, LONG_OPT_LAYOUT_ONLY},
{"debugger-test",no_argument, 0, LONG_OPT_DEBUGGER_TEST},
{"input-filter", required_argument,0, LONG_OPT_IN_FILTER},
{"output-filter",required_argument,0, LONG_OPT_OUT_FILTER},
{"error-filter", required_argument,0, LONG_OPT_ERR_FILTER},
{"pty", no_argument, 0, LONG_OPT_PTY},
{NULL}
};
char *opt_string = "+hlQuvV";
opt.progname = xbasename(argv[0]);
optind = 0;
while((opt_char = getopt_long(argc, argv, opt_string,
long_options, &option_index)) != -1) {
switch (opt_char) {
case '?':
fprintf(stderr, "Try \"sattach --help\" for more "
"information\n");
exit(error_exit);
break;
case 'h':
_help();
exit(0);
case 'l':
opt.labelio = true;
break;
case 'Q':
opt.quiet++;
break;
case 'u':
_usage();
exit(0);
case 'v':
opt.verbose++;
break;
case 'V':
print_slurm_version();
exit(0);
break;
case LONG_OPT_IN_FILTER:
if (xstrcmp(optarg, "-") != 0) {
opt.input_filter = (uint32_t)
_get_pos_int(optarg, "input-filter");
}
opt.input_filter_set = true;
break;
case LONG_OPT_OUT_FILTER:
if (xstrcmp(optarg, "-") != 0) {
opt.output_filter = (uint32_t)
_get_pos_int(optarg, "output-filter");
}
opt.output_filter_set = true;
break;
case LONG_OPT_ERR_FILTER:
if (xstrcmp(optarg, "-") != 0) {
opt.error_filter = (uint32_t)
_get_pos_int(optarg, "error-filter");
}
opt.error_filter_set = true;
break;
case LONG_OPT_LAYOUT_ONLY:
opt.layout_only = true;
break;
case LONG_OPT_DEBUGGER_TEST:
opt.debugger_test = true;
break;
case LONG_OPT_PTY:
#ifdef HAVE_PTY_H
opt.pty = true;
#else
error("--pty not currently supported on this system "
"type");
#endif
break;
default:
error("Unrecognized command line parameter %c",
opt_char);
exit(error_exit);
}
}
}
static int _fastcall _list( LPTSTR pszFileName )
{
register int c, i;
TCHAR szDescription[512], szHeader[132], szLine[32];
long lTemp, lRow;
POPWINDOWPTR wn = NULL;
FILESEARCH dir;
// get default normal and inverse attributes
if ( gpIniptr->ListColor != 0 ) {
SetScrColor( nScreenRows, nScreenColumns, gpIniptr->ListColor );
}
// set colors
GetAtt( (unsigned int *)&nNormal, (unsigned int *)&nInverse );
if ( gpIniptr->ListStatusColor != 0 )
nInverse = gpIniptr->ListStatusColor;
// flip the first line to inverse video
clear_header();
// open the file & initialize buffers
if ( ListOpenFile( pszFileName ))
return ERROR_EXIT;
// kludge for empty files or pipes
if ( LFile.lSize == 0L )
LFile.lSize = 1L;
for ( ; ; ) {
// display header
if ( fDirtyHeader ) {
clear_header();
sprintf( szHeader, LIST_HEADER, fname_part(LFile.szName), gchVerticalBar, gchVerticalBar, gchVerticalBar );
WriteStrAtt( 0, 0, nInverse, szHeader );
fDirtyHeader = 0;
}
// display location within file
// (don't use color_printf() so we won't have
// problems with windowed sessions)
i = sprintf( szHeader, LIST_LINE, LFile.nListHorizOffset, LFile.lCurrentLine + gpIniptr->ListRowStart, (int)((( LFile.lViewPtr + 1 ) * 100 ) / LFile.lSize ));
WriteStrAtt( 0, ( nScreenColumns - i ), nInverse, szHeader );
SetCurPos( 0, 0 );
if ( lListFlags & LIST_SEARCH ) {
lListFlags &= ~LIST_SEARCH;
fSearchFlags = 0;
if ( lListFlags & LIST_REVERSE ) {
c = LIST_FIND_CHAR_REVERSE;
fSearchFlags |= FFIND_REVERSE_SEARCH;
// goto the last row
while ( ListMoveLine( 1 ) != 0 )
;
} else
c = LIST_FIND_CHAR;
if ( lListFlags & LIST_NOWILDCARDS )
fSearchFlags |= FFIND_NOWILDCARDS;
bListSkipLine = 0;
goto FindNext;
}
// get the key from the BIOS, because
// STDIN might be redirected
if ((( c = cvtkey( GetKeystroke( EDIT_NO_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT), MAP_GEN | MAP_LIST)) == (TCHAR)ESC ))
break;
switch ( c ) {
case CTRLC:
return CTRLC;
case CUR_LEFT:
case CTL_LEFT:
if (( lListFlags & LIST_WRAP ) || ( LFile.nListHorizOffset == 0 ))
goto bad_key;
if (( LFile.nListHorizOffset -= (( c == CUR_LEFT ) ? 8 : 40 )) < 0 )
LFile.nListHorizOffset = 0;
break;
case CUR_RIGHT:
case CTL_RIGHT:
if (( lListFlags & LIST_WRAP ) || ( LFile.nListHorizOffset >= MAXLISTLINE + 1 ))
goto bad_key;
if ((LFile.nListHorizOffset += ((c == CUR_RIGHT) ? 8 : 40 )) > MAXLISTLINE + 1 )
LFile.nListHorizOffset = MAXLISTLINE+1;
break;
case CUR_UP:
if ( ListMoveLine( -1 ) == 0 )
goto bad_key;
Scroll(1, 0, nScreenRows, nScreenColumns, -1, nNormal);
DisplayLine( 1, LFile.lViewPtr );
continue;
case CUR_DOWN:
if ( ListMoveLine( 1 ) == 0 )
goto bad_key;
Scroll( 1, 0, nScreenRows, nScreenColumns, 1, nNormal );
// display last line
lTemp = LFile.lViewPtr;
lRow = (nScreenRows - 1);
lTemp += MoveViewPtr( lTemp, &lRow );
if ( lRow == ( nScreenRows - 1 ))
DisplayLine( nScreenRows, lTemp );
continue;
case HOME:
ListHome();
break;
case END:
// goto the last row
list_wait( LIST_WAIT );
while ( ListMoveLine( 1 ) != 0 )
;
case PgUp:
// already at TOF?
if ( LFile.lViewPtr == 0L )
goto bad_key;
for ( i = 1; (( i < nScreenRows ) && ( ListMoveLine( -1 ) != 0 )); i++ )
;
break;
case PgDn:
case SPACE:
if ( ListMoveLine( nScreenRows - 1 ) == 0 )
goto bad_key;
break;
case F1: // help
// don't allow a ^X exit from HELP
_help( gpInternalName, HELP_NX );
continue;
case TAB:
// change tab size
// disable ^C / ^BREAK handling
HoldSignals();
wn = wOpen( 2, 5, 4, strlen( LIST_TABSIZE ) + 10, nInverse, LIST_TABSIZE_TITLE, NULL );
wn->nAttrib = nNormal;
wClear();
wWriteListStr( 0, 1, wn, LIST_TABSIZE );
egets( szLine, 2, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF | EDIT_DIGITS));
wRemove( wn );
if (( i = atoi( szLine )) > 0 )
TABSIZE = i;
// enable ^C / ^BREAK handling
EnableSignals();
break;
case DEL:
// delete this file
if (( lListFlags & LIST_STDIN ) == 0 ) {
// disable ^C / ^BREAK handling
HoldSignals();
wn = wOpen( 2, 5, 4, strlen( LIST_DELETE ) + 10, nInverse, LIST_DELETE_TITLE, NULL );
wn->nAttrib = nNormal;
wClear();
wWriteListStr( 0, 1, wn, LIST_DELETE );
i = GetKeystroke( EDIT_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT );
wRemove( wn );
// enable ^C / ^BREAK handling
EnableSignals();
if ( i == (TCHAR)YES_CHAR ) {
if ( LFile.hHandle > 0 )
_close( LFile.hHandle );
LFile.hHandle = -1;
remove( pszFileName );
return 0;
}
}
break;
case INS:
// save to a file
ListSaveFile();
break;
case LIST_INFO_CHAR:
{
unsigned int uSize = 1024;
TCHAR _far *lpszText, _far *lpszArg;
int fFSType, fSFN = 1;
TCHAR szBuf[16];
DOSFILEDATE laDir, crDir;
// disable ^C / ^BREAK handling
HoldSignals();
memset( &dir, '\0', sizeof(FILESEARCH) );
if (( lListFlags & LIST_STDIN ) == 0 ) {
if ( find_file( FIND_FIRST, LFile.szName, 0x07 | FIND_CLOSE | FIND_EXACTLY, &dir, NULL ) == NULL ) {
honk();
continue;
}
}
// display info on the current file
i = (( lListFlags & LIST_STDIN ) ? 5 : 10 );
if (( fFSType = ifs_type( LFile.szName )) != FAT )
i = 11;
wn = wOpen( 2, 1, i, 77, nInverse, gpInternalName, NULL );
wn->nAttrib = nNormal;
wClear();
i = 0;
if ( lListFlags & LIST_STDIN )
wWriteStrAtt( 0, 1, nNormal, LIST_INFO_PIPE );
else {
szDescription[0] = _TEXT('\0');
process_descriptions( LFile.szName, szDescription, DESCRIPTION_READ );
lpszText = lpszArg = (TCHAR _far *)AllocMem( &uSize );
strcpy(szBuf, FormatDate( dir.fd.file_date.months, dir.fd.file_date.days, dir.fd.file_date.years + 80, 0 ));
if (fFSType != FAT) {
FileTimeToDOSTime( &(dir.ftLastAccessTime), &( laDir.ft.wr_time), &( laDir.fd.wr_date) );
FileTimeToDOSTime( &(dir.ftCreationTime), &(crDir.ft.wr_time), &(crDir.fd.wr_date) );
strcpy( szLine, FormatDate( laDir.fd.file_date.months, laDir.fd.file_date.days, laDir.fd.file_date.years + 80, 0 ));
sprintf_far( lpszText, LIST_INFO_LFN,
LFile.szName, szDescription, dir.ulSize,
szBuf,
dir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0],dir.ft.file_time.minutes,
szLine,
laDir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0], laDir.ft.file_time.minutes,
FormatDate( crDir.fd.file_date.months, crDir.fd.file_date.days, crDir.fd.file_date.years + 80, 0 ),
crDir.ft.file_time.hours, gaCountryInfo.szTimeSeparator[0], crDir.ft.file_time.minutes);
} else {
sprintf_far( lpszText, LIST_INFO_FAT,
LFile.szName, szDescription, dir.ulSize,
szBuf, dir.ft.file_time.hours,
gaCountryInfo.szTimeSeparator[0],dir.ft.file_time.minutes );
}
// print the text
for ( ; ( *lpszArg != _TEXT('\0') ); i++ ) {
sscanf_far( lpszArg, _TEXT("%[^\n]%*c%n"), szHeader, &uSize );
// allow for long filenames ...
if (( i == 0 ) && ( strlen( szHeader ) > 73 )) {
c = szHeader[73];
szHeader[73] = _TEXT('\0');
wWriteStrAtt( i++, 1, nNormal, szHeader );
szHeader[73] = (TCHAR)c;
wWriteStrAtt( i, 15, nNormal, szHeader+73 );
fSFN = 0;
} else
wWriteStrAtt( i, 1, nNormal, szHeader );
lpszArg += uSize;
}
FreeMem( lpszText );
}
wWriteListStr( i+fSFN, 1, wn, PAUSE_PROMPT );
GetKeystroke( EDIT_NO_ECHO | EDIT_BIOS_KEY );
wRemove( wn );
// enable ^C / ^BREAK handling
EnableSignals();
continue;
}
case LIST_GOTO_CHAR:
// goto the specified line / hex offset
// disable ^C / ^BREAK handling
HoldSignals();
wn = wOpen( 2, 5, 4, strlen( LIST_GOTO_OFFSET ) + 20, nInverse, LIST_GOTO_TITLE, NULL );
wn->nAttrib = nNormal;
wClear();
wWriteListStr( 0, 1, wn, (( lListFlags & LIST_HEX) ? LIST_GOTO_OFFSET : LIST_GOTO));
i = egets( szLine, 10, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF));
wRemove( wn );
// enable ^C / ^BREAK handling
EnableSignals();
if ( i == 0 )
break;
list_wait( LIST_WAIT );
// if in hex mode, jump to offset
if ( lListFlags & LIST_HEX ) {
strupr( szLine );
sscanf( szLine, _TEXT("%lx"), &lRow );
lRow = lRow / 0x10;
} else if ( sscanf( szLine, FMT_LONG, &lRow ) == 0 )
continue;
lRow -= gpIniptr->ListRowStart;
if ( lRow >= 0 ) {
LFile.lViewPtr = MoveViewPtr( 0L, &lRow );
LFile.lCurrentLine = lRow;
} else {
LFile.lViewPtr += MoveViewPtr( LFile.lViewPtr, &lRow );
LFile.lCurrentLine += lRow;
}
break;
case LIST_HIBIT_CHAR:
// toggle high bit filter
lListFlags ^= LIST_HIBIT;
break;
case LIST_WRAP_CHAR:
// toggle line wrap
lListFlags ^= LIST_WRAP;
nRightMargin = (( lListFlags & LIST_WRAP ) ? GetScrCols() : MAXLISTLINE );
// recalculate current line
list_wait( LIST_WAIT );
// get start of line
LFile.nListHorizOffset = 0;
// line number probably changed, so recompute everything
LFile.lCurrentLine = ComputeLines( 0L, LFile.lViewPtr );
LFile.lViewPtr = MoveViewPtr( 0L, &(LFile.lCurrentLine ));
break;
case LIST_HEX_CHAR:
// toggle hex display
lListFlags ^= LIST_HEX;
// if hex, reset to previous 16-byte
// boundary
if ( lListFlags & LIST_HEX ) {
LFile.lViewPtr -= ( LFile.lViewPtr % 16 );
} else {
// if not hex, reset to start of line
ListMoveLine( 1 );
ListMoveLine( -1 );
}
// recalculate current line
list_wait( LIST_WAIT );
LFile.lCurrentLine = ComputeLines( 0L, LFile.lViewPtr );
break;
case LIST_FIND_CHAR:
case LIST_FIND_CHAR_REVERSE:
// find first matching string
bListSkipLine = 0;
//lint -fallthrough
case LIST_FIND_NEXT_CHAR:
case LIST_FIND_NEXT_CHAR_REVERSE:
// find next matching string
if (( c == LIST_FIND_CHAR ) || ( c == LIST_FIND_CHAR_REVERSE )) {
// disable ^C / ^BREAK handling
HoldSignals();
fSearchFlags = 0;
wn = wOpen( 2, 1, 4, 75, nInverse, (( c == LIST_FIND_NEXT_CHAR_REVERSE ) ? LIST_FIND_TITLE_REVERSE : LIST_FIND_TITLE ), NULL );
wn->nAttrib = nNormal;
wClear();
if ( lListFlags & LIST_HEX ) {
wWriteListStr( 0, 1, wn, LIST_FIND_HEX );
if ( GetKeystroke( EDIT_ECHO | EDIT_BIOS_KEY | EDIT_UC_SHIFT ) == YES_CHAR )
fSearchFlags |= FFIND_HEX_SEARCH;
wClear();
}
wWriteListStr( 0, 1, wn, LIST_FIND );
egets( szListFindWhat, 64, (EDIT_DIALOG | EDIT_BIOS_KEY | EDIT_NO_CRLF));
wRemove( wn );
// enable ^C / ^BREAK handling
EnableSignals();
} else {
FindNext:
// a "Next" has to be from current position
fSearchFlags &= ~FFIND_TOPSEARCH;
}
if ( szListFindWhat[0] == _TEXT('\0') )
continue;
sprintf( szDescription, LIST_FIND_WAIT, szListFindWhat );
list_wait( szDescription );
// save start position
lTemp = LFile.lViewPtr;
lRow = LFile.lCurrentLine;
if (( c == LIST_FIND_CHAR_REVERSE ) || ( c == LIST_FIND_NEXT_CHAR_REVERSE )) {
// start on the previous line
fSearchFlags |= FFIND_REVERSE_SEARCH;
} else {
fSearchFlags &= ~FFIND_REVERSE_SEARCH;
// skip the first line (except on /T"xxx")
if ( bListSkipLine )
ListMoveLine( 1 );
}
bListSkipLine = 1;
if ( SearchFile( fSearchFlags ) != 1 ) {
ListSetCurrent( lTemp );
LFile.lViewPtr = lTemp;
LFile.lCurrentLine = lRow;
} else
LFile.fDisplaySearch = (( fSearchFlags & FFIND_CHECK_CASE ) ? 2 : 1 );
break;
case LIST_PRINT_CHAR:
// print the file
ListPrintFile();
continue;
case LIST_CONTINUE_CHAR:
case CTL_PgDn:
return 0;
case LIST_PREVIOUS_CHAR:
case CTL_PgUp:
// previous file
if ( nCurrent > 0 ) {
nCurrent--;
return 0;
}
//lint -fallthrough
default:
bad_key:
honk();
continue;
}
// rewrite the display
ListUpdateScreen();
}
return 0;
}
/*
* 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();
}
// run the menu
void
Menu::run(void)
{
uint8_t len, i, ret;
uint8_t argc;
int c;
char *s;
// loop performing commands
for (;;) {
// run the pre-prompt function, if one is defined
if ((NULL != _ppfunc) && !_ppfunc())
return;
// loop reading characters from the input
len = 0;
Serial.printf("%S] ", _prompt);
for (;;) {
c = Serial.read();
if (-1 == c)
continue;
// carriage return -> process command
if ('\r' == c) {
_inbuf[len] = '\0';
Serial.write('\r');
Serial.write('\n');
break;
}
// backspace
if ('\b' == c) {
if (len > 0) {
len--;
Serial.write('\b');
Serial.write(' ');
Serial.write('\b');
continue;
}
}
// printable character
if (isprint(c) && (len < (MENU_COMMANDLINE_MAX - 1))) {
_inbuf[len++] = c;
Serial.write((char)c);
continue;
}
}
// split the input line into tokens
argc = 0;
_argv[argc++].str = strtok_r(_inbuf, " ", &s);
// XXX should an empty line by itself back out of the current menu?
while (argc <= MENU_ARGS_MAX) {
_argv[argc].str = strtok_r(NULL, " ", &s);
if ('\0' == _argv[argc].str)
break;
_argv[argc].i = atol(_argv[argc].str);
_argv[argc].f = atof(_argv[argc].str); // calls strtod, > 700B !
argc++;
}
// look for a command matching the first word (note that it may be empty)
for (i = 0; i < _entries; i++) {
if (!strcasecmp_P(_argv[0].str, _commands[i].command)) {
ret = _call(i, argc);
if (-2 == ret)
return;
break;
}
}
// implicit commands
if (i == _entries) {
if (!strcmp(_argv[0].str, "?") || (!strcasecmp_P(_argv[0].str, PSTR("help")))) {
_help();
} else if (!strcasecmp_P(_argv[0].str, PSTR("exit"))) {
return;
}
}
}
}
/*
* opt_args() : set options via commandline args and getopt_long
*/
static void _opt_args(int argc, char **argv)
{
int opt_char;
int option_index;
static struct option long_options[] = {
{"account", required_argument, 0, 'A'},
{"batch", no_argument, 0, 'b'},
{"ctld", no_argument, 0, OPT_LONG_CTLD},
{"help", no_argument, 0, OPT_LONG_HELP},
{"interactive", no_argument, 0, 'i'},
{"cluster", required_argument, 0, 'M'},
{"clusters", required_argument, 0, 'M'},
{"name", required_argument, 0, 'n'},
{"nodelist", required_argument, 0, 'w'},
{"partition", required_argument, 0, 'p'},
{"qos", required_argument, 0, 'q'},
{"quiet", no_argument, 0, 'Q'},
{"reservation", required_argument, 0, 'R'},
{"signal", required_argument, 0, 's'},
{"state", required_argument, 0, 't'},
{"usage", no_argument, 0, OPT_LONG_USAGE},
{"user", required_argument, 0, 'u'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"wckey", required_argument, 0, OPT_LONG_WCKEY},
{NULL, 0, 0, 0}
};
while ((opt_char = getopt_long(argc, argv, "A:biM:n:p:Qq:R:s:t:u:vVw:",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr,
"Try \"scancel --help\" for more "
"information\n");
exit(1);
break;
case (int)'A':
opt.account = xstrtolower(xstrdup(optarg));
break;
case (int)'b':
opt.batch = true;
break;
case OPT_LONG_CTLD:
opt.ctld = true;
break;
case (int)'i':
opt.interactive = true;
break;
case (int)'M':
opt.ctld = true;
FREE_NULL_LIST(opt.clusters);
opt.clusters = slurmdb_get_info_cluster(optarg);
if (!opt.clusters) {
print_db_notok(optarg, 0);
exit(1);
}
working_cluster_rec = list_peek(opt.clusters);
break;
case (int)'n':
opt.job_name = xstrdup(optarg);
break;
case (int)'p':
opt.partition = xstrdup(optarg);
break;
case (int)'Q':
opt.verbose = -1;
break;
case (int)'q':
opt.qos = xstrtolower(xstrdup(optarg));
break;
case (int)'R':
opt.reservation = xstrdup(optarg);
break;
case (int)'s':
opt.signal = _xlate_signal_name(optarg);
break;
case (int)'t':
opt.state = _xlate_state_name(optarg, false);
break;
case (int)'u':
opt.user_name = xstrdup(optarg);
break;
case (int)'v':
opt.verbose++;
break;
case (int)'V':
print_slurm_version ();
exit(0);
case (int)'w':
opt.nodelist = xstrdup(optarg);
break;
case OPT_LONG_WCKEY:
opt.wckey = xstrdup(optarg);
break;
case OPT_LONG_HELP:
_help();
exit(0);
case OPT_LONG_USAGE:
_usage();
exit(0);
}
}
if (optind < argc) {
char **rest = argv + optind;
opt.job_list = rest;
_xlate_job_step_ids(rest);
}
if (!_opt_verify())
exit(1);
}
/*
* 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[])
{
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();
}
/* Help action */
static int
disp_help (struct mh_whatnow_env *wh, int argc, char **argv, int *status)
{
return _help (disposition_helptab, argv[0]);
}
