static
void
_print_version_and_license(const char *pname, int status) {
_print_version(pname);
fprintf(stderr,
" Copyright (c) 2003-2007 Yuta Mori All Rights Reserved.\n"
"\n"
" Permission is hereby granted, free of charge, to any person\n"
" obtaining a copy of this software and associated documentation\n"
" files (the \"Software\"), to deal in the Software without\n"
" restriction, including without limitation the rights to use,\n"
" copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
" copies of the Software, and to permit persons to whom the\n"
" Software is furnished to do so, subject to the following\n"
" conditions:\n"
"\n"
" The above copyright notice and this permission notice shall be\n"
" included in all copies or substantial portions of the Software.\n"
"\n"
" THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n"
" OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n"
" HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n"
" WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n"
" FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n"
" OTHER DEALINGS IN THE SOFTWARE.\n");
exit(status);
}
static
bool
_process_option (struct arguments_definition *def,
int opt,
const char *optarg,
int argc,
char *argv[])
{
struct arguments *args = def->user_data;
bool go_on = true;
switch (opt) {
case '?': /* invalid option */
go_on = false;
break;
case ':': /* invalid argument */
case 'h':
print_usage (def, argv[0]);
go_on = false;
break;
case 'V':
_print_version ();
go_on = false;
break;
case 'f':
strncpy (args->format, optarg, sizeof (args->format));
args->format[sizeof (args->format) - 1] = '\0';
break;
}
return go_on;
}
static
void
_print_usage(const char *pname, int status) {
_print_version(pname);
fprintf(stderr,
"usage: %s [OPTION]... PATTERN FILE SAFILE\n"
"\nOutput control:\n"
" -m NUM stop after NUM matches\n"
" -b print the byte offset\n"
" -H print the filename\n"
" -c only print a count of matches\n"
" -S sort in lexicographical order\n"
"\nContext control:\n"
" -B NUM print NUM characters of leading context\n"
" -A NUM print NUM characters of trailing context\n"
" -C NUM print NUM characters of output context\n"
"\nMiscellaneous:\n"
" -h print this message\n"
" -v display version number\n"
"\n", pname);
exit(status);
}
int main(int argc, char **argv)
{
int error_code = SLURM_SUCCESS, i, opt_char, input_field_count;
char **input_fields;
log_options_t opts = LOG_OPTS_STDERR_ONLY ;
int local_exit_code = 0;
char *temp = NULL;
int option_index;
static struct option long_options[] = {
{"help", 0, 0, 'h'},
{"usage", 0, 0, 'h'},
{"immediate",0, 0, 'i'},
{"noheader",0, 0, 'n'},
{"oneliner", 0, 0, 'o'},
{"parsable", 0, 0, 'p'},
{"parsable2", 0, 0, 'P'},
{"quiet", 0, 0, 'Q'},
{"readonly", 0, 0, 'r'},
{"associations", 0, 0, 's'},
{"verbose", 0, 0, 'v'},
{"version", 0, 0, 'V'},
{NULL, 0, 0, 0}
};
command_name = argv[0];
rollback_flag = 1;
exit_code = 0;
exit_flag = 0;
input_field_count = 0;
quiet_flag = 0;
readonly_flag = 0;
verbosity = 0;
slurm_conf_init(NULL);
log_init("sacctmgr", opts, SYSLOG_FACILITY_DAEMON, NULL);
while((opt_char = getopt_long(argc, argv, "hionpPQrsvV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"sacctmgr --help\" "
"for more information\n");
exit(1);
break;
case (int)'h':
_usage ();
exit(exit_code);
break;
case (int)'i':
rollback_flag = 0;
break;
case (int)'o':
one_liner = 1;
break;
case (int)'n':
print_fields_have_header = 0;
break;
case (int)'p':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_ENDING;
break;
case (int)'P':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_NO_ENDING;
break;
case (int)'Q':
quiet_flag = 1;
break;
case (int)'r':
readonly_flag = 1;
break;
case (int)'s':
with_assoc_flag = 1;
break;
case (int)'v':
quiet_flag = -1;
verbosity++;
break;
case (int)'V':
_print_version();
exit(exit_code);
break;
default:
exit_code = 1;
fprintf(stderr, "getopt error, returned %c\n",
opt_char);
exit(exit_code);
}
}
if (argc > MAX_INPUT_FIELDS) /* bogus input, but continue anyway */
input_words = argc;
else
input_words = 128;
input_fields = (char **) xmalloc (sizeof (char *) * input_words);
if (optind < argc) {
for (i = optind; i < argc; i++) {
input_fields[input_field_count++] = argv[i];
}
}
if (verbosity) {
opts.stderr_level += verbosity;
opts.prefix_level = 1;
log_alter(opts, 0, NULL);
}
/* Check to see if we are running a supported accounting plugin */
temp = slurm_get_accounting_storage_type();
if (xstrcasecmp(temp, "accounting_storage/slurmdbd")
&& xstrcasecmp(temp, "accounting_storage/mysql")) {
fprintf (stderr, "You are not running a supported "
"accounting_storage plugin\n(%s).\n"
"Only 'accounting_storage/slurmdbd' "
"and 'accounting_storage/mysql' are supported.\n",
temp);
xfree(temp);
exit(1);
}
xfree(temp);
errno = 0;
db_conn = slurmdb_connection_get();
if (errno != SLURM_SUCCESS) {
int tmp_errno = errno;
if ((input_field_count == 2) &&
(!strncasecmp(argv[2], "Configuration", strlen(argv[1]))) &&
((!strncasecmp(argv[1], "list", strlen(argv[0]))) ||
(!strncasecmp(argv[1], "show", strlen(argv[0]))))) {
if (tmp_errno == ESLURM_DB_CONNECTION) {
tmp_errno = 0;
sacctmgr_list_config(true);
} else
sacctmgr_list_config(false);
}
errno = tmp_errno;
if (errno)
error("Problem talking to the database: %m");
exit(1);
}
my_uid = getuid();
if (input_field_count)
exit_flag = 1;
else
error_code = _get_command (&input_field_count, input_fields);
while (error_code == SLURM_SUCCESS) {
error_code = _process_command (input_field_count,
input_fields);
if (error_code || exit_flag)
break;
error_code = _get_command (&input_field_count, input_fields);
/* This is here so if someone made a mistake we allow
* them to fix it and let the process happen since there
* are checks for global exit_code we need to reset it.
*/
if (exit_code) {
local_exit_code = exit_code;
exit_code = 0;
}
}
/* readline library writes \n when echoes the input string, it does
* not when it sees the EOF, so in that case we have to print it to
* align the terminal prompt.
*/
if (exit_flag == 2)
putchar('\n');
if (local_exit_code)
exit_code = local_exit_code;
acct_storage_g_close_connection(&db_conn);
slurm_acct_storage_fini();
FREE_NULL_LIST(g_qos_list);
FREE_NULL_LIST(g_res_list);
FREE_NULL_LIST(g_tres_list);
exit(exit_code);
}
/*
* _process_command - process the user's command
* IN argc - count of arguments
* IN argv - the arguments
* RET 0 or errno (only for errors fatal to sacctmgr)
*/
static int _process_command (int argc, char **argv)
{
int command_len = 0, rc;
if (argc < 1) {
exit_code = 1;
if (quiet_flag == -1)
fprintf(stderr, "no input");
return 0;
}
command_len = strlen(argv[0]);
if (strncasecmp (argv[0], "associations",
MAX(command_len, 3)) == 0) {
with_assoc_flag = 1;
} else if (strncasecmp (argv[0], "dump", MAX(command_len, 3)) == 0) {
sacctmgr_dump_cluster((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "help", MAX(command_len, 2)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for keyword:%s\n",
argv[0]);
}
_usage ();
} else if (strncasecmp (argv[0], "load", MAX(command_len, 2)) == 0) {
load_sacctmgr_cfg_file((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "oneliner",
MAX(command_len, 1)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for keyword:%s\n",
argv[0]);
}
one_liner = 1;
} else if (strncasecmp (argv[0], "quiet", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr, "too many arguments for keyword:%s\n",
argv[0]);
}
quiet_flag = 1;
} else if ((strncasecmp (argv[0], "exit", MAX(command_len, 4)) == 0) ||
(strncasecmp (argv[0], "\\q", MAX(command_len, 2)) == 0) ||
(strncasecmp (argv[0], "quit", MAX(command_len, 4)) == 0)) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for keyword:%s\n",
argv[0]);
}
exit_flag = 1;
} else if ((strncasecmp (argv[0], "add", MAX(command_len, 3)) == 0) ||
(strncasecmp (argv[0], "create",
MAX(command_len, 3)) == 0)) {
_add_it((argc - 1), &argv[1]);
} else if ((strncasecmp (argv[0], "archive",
MAX(command_len, 3)) == 0)) {
_archive_it((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "clear", MAX(command_len, 3)) == 0) {
_clear_it((argc - 1), &argv[1]);
} else if ((strncasecmp (argv[0], "show", MAX(command_len, 3)) == 0) ||
(strncasecmp (argv[0], "list", MAX(command_len, 3)) == 0)) {
_show_it((argc - 1), &argv[1]);
} else if (!strncasecmp (argv[0], "modify", MAX(command_len, 1))
|| !strncasecmp (argv[0], "update", MAX(command_len, 1))) {
_modify_it((argc - 1), &argv[1]);
} else if ((strncasecmp (argv[0], "delete",
MAX(command_len, 3)) == 0) ||
(strncasecmp (argv[0], "remove",
MAX(command_len, 3)) == 0)) {
_delete_it((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "verbose", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
quiet_flag = -1;
} else if (strncasecmp (argv[0], "readonly",
MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
readonly_flag = 1;
} else if (strncasecmp (argv[0], "reconfigure",
MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
slurmdb_reconfig(db_conn);
} else if (strncasecmp (argv[0], "rollup", MAX(command_len, 2)) == 0) {
time_t my_start = 0;
time_t my_end = 0;
uint16_t archive_data = 0;
if (argc > 4) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
if (argc > 1)
my_start = parse_time(argv[1], 1);
if (argc > 2)
my_end = parse_time(argv[2], 1);
if (argc > 3)
archive_data = atoi(argv[3]);
if (acct_storage_g_roll_usage(db_conn, my_start,
my_end, archive_data, NULL)
== SLURM_SUCCESS) {
if (commit_check("Would you like to commit rollup?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Rollup Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
} else if (strncasecmp (argv[0], "shutdown",
MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
rc = slurmdb_shutdown(db_conn);
if (rc != SLURM_SUCCESS) {
fprintf(stderr, " Problem shutting down server: %s\n",
slurm_strerror(rc));
exit_code = 1;
}
} else if (strncasecmp (argv[0], "version", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
_print_version();
} else {
exit_code = 1;
fprintf (stderr, "invalid keyword: %s\n", argv[0]);
}
return 0;
}
static
bool
_process_option (struct arguments_definition *def,
int opt,
const char *optarg,
int argc,
char *argv[])
{
struct arguments *args = def->user_data;
bool go_on = true;
switch (opt) {
case '?': /* invalid option */
go_on = false;
break;
case ':': /* invalid argument */
case 'h':
print_usage (def, argv[0]);
go_on = false;
break;
case 'V':
_print_version ();
go_on = false;
break;
case 500:
args->list_details = true;
break;
case 'A':
args->list_by_account = true;
break;
case 'D':
args->list_by_date = true;
break;
case 'T':
args->list_total = true;
break;
case 'a':
strncpy (args->account, optarg, 4);
args->account[3] = '\0';
break;
case 'f':
strncpy (args->from_date, optarg, 9);
args->from_date[8] = '\0';
break;
case 't':
strncpy (args->to_date, optarg, 9);
args->to_date[8] = '\0';
break;
case 'd':
strncpy (args->from_date, optarg, 9);
args->from_date[8] = '\0';
strcpy (args->to_date, args->from_date);
break;
case 'i':
args->invert_amounts = true;
break;
default: /* unhandled option */
fprintf (stderr, "Unhandled option %d\n", opt);
go_on = false;
break;
}
return go_on;
}
int main (int argc, char **argv)
{
int opt_char;
log_options_t opts = LOG_OPTS_STDERR_ONLY;
shares_request_msg_t req_msg;
char *temp = NULL;
int option_index;
bool all_users = 0;
static struct option long_options[] = {
{"accounts", 1, 0, 'A'},
{"all", 0, 0, 'a'},
{"helpformat",0,0, 'e'},
{"long", 0, 0, 'l'},
{"partition",0, 0, 'm'},
{"cluster", 1, 0, 'M'},
{"clusters", 1, 0, 'M'},
{"noheader", 0, 0, 'n'},
{"format", 1, 0, 'o'},
{"parsable", 0, 0, 'p'},
{"parsable2",0, 0, 'P'},
{"users", 1, 0, 'u'},
{"Users", 0, 0, 'U'},
{"verbose", 0, 0, 'v'},
{"version", 0, 0, 'V'},
{"help", 0, 0, OPT_LONG_HELP},
{"usage", 0, 0, OPT_LONG_USAGE},
{NULL, 0, 0, 0}
};
exit_code = 0;
long_flag = 0;
quiet_flag = 0;
verbosity = 0;
memset(&req_msg, 0, sizeof(shares_request_msg_t));
slurm_conf_init(NULL);
log_init("sshare", opts, SYSLOG_FACILITY_DAEMON, NULL);
while ((opt_char = getopt_long(argc, argv, "aA:ehlM:no:pPqUu:t:vVm",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"sshare --help\" "
"for more information\n");
exit(1);
break;
case 'a':
all_users = 1;
break;
case 'A':
if (!req_msg.acct_list)
req_msg.acct_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(req_msg.acct_list, optarg);
break;
case 'e':
_help_format_msg();
exit(0);
break;
case 'h':
print_fields_have_header = 0;
break;
case 'l':
long_flag = 1;
break;
case 'M':
FREE_NULL_LIST(clusters);
if (!(clusters =
slurmdb_get_info_cluster(optarg))) {
print_db_notok(optarg, 0);
exit(1);
}
working_cluster_rec = list_peek(clusters);
break;
case 'm':
options |= PRINT_PARTITIONS;
break;
case 'n':
print_fields_have_header = 0;
break;
case 'o':
xstrfmtcat(opt_field_list, "%s,", optarg);
break;
case 'p':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_ENDING;
break;
case 'P':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_NO_ENDING;
break;
case 'u':
if (!xstrcmp(optarg, "-1")) {
all_users = 1;
break;
}
all_users = 0;
if (!req_msg.user_list)
req_msg.user_list =
list_create(slurm_destroy_char);
_addto_name_char_list(req_msg.user_list, optarg, 0);
break;
case 'U':
options |= PRINT_USERS_ONLY;
break;
case 'v':
quiet_flag = -1;
verbosity++;
break;
case 'V':
_print_version();
exit(exit_code);
break;
case OPT_LONG_HELP:
case OPT_LONG_USAGE:
_usage();
exit(0);
default:
exit_code = 1;
fprintf(stderr, "getopt error, returned %c\n",
opt_char);
exit(exit_code);
}
}
if (verbosity) {
opts.stderr_level += verbosity;
opts.prefix_level = 1;
log_alter(opts, 0, NULL);
}
if (all_users) {
if (req_msg.user_list
&& list_count(req_msg.user_list)) {
FREE_NULL_LIST(req_msg.user_list);
}
if (verbosity)
fprintf(stderr, "Users requested:\n\t: all\n");
} else if (verbosity && req_msg.user_list
&& list_count(req_msg.user_list)) {
fprintf(stderr, "Users requested:\n");
ListIterator itr = list_iterator_create(req_msg.user_list);
while ((temp = list_next(itr)))
fprintf(stderr, "\t: %s\n", temp);
list_iterator_destroy(itr);
} else if (!req_msg.user_list || !list_count(req_msg.user_list)) {
struct passwd *pwd;
if ((pwd = getpwuid(getuid()))) {
if (!req_msg.user_list) {
req_msg.user_list =
list_create(slurm_destroy_char);
}
temp = xstrdup(pwd->pw_name);
list_append(req_msg.user_list, temp);
if (verbosity) {
fprintf(stderr, "Users requested:\n");
fprintf(stderr, "\t: %s\n", temp);
}
}
}
if (req_msg.acct_list && list_count(req_msg.acct_list)) {
if (verbosity) {
fprintf(stderr, "Accounts requested:\n");
ListIterator itr = list_iterator_create(req_msg.acct_list);
while ((temp = list_next(itr)))
fprintf(stderr, "\t: %s\n", temp);
list_iterator_destroy(itr);
}
} else {
if (req_msg.acct_list
&& list_count(req_msg.acct_list)) {
FREE_NULL_LIST(req_msg.acct_list);
}
if (verbosity)
fprintf(stderr, "Accounts requested:\n\t: all\n");
}
if (clusters)
exit_code = _multi_cluster(&req_msg);
else
exit_code = _single_cluster(&req_msg);
exit(exit_code);
}
int
main (int argc, char *argv[])
{
int error_code = SLURM_SUCCESS, opt_char;
log_options_t opts = LOG_OPTS_STDERR_ONLY;
shares_request_msg_t req_msg;
shares_response_msg_t *resp_msg = NULL;
char *temp = NULL;
int option_index;
bool all_users = 0;
static struct option long_options[] = {
{"accounts", 1, 0, 'A'},
{"all", 0, 0, 'a'},
{"long", 0, 0, 'l'},
{"cluster", 1, 0, 'M'},
{"clusters", 1, 0, 'M'},
{"noheader", 0, 0, 'h'},
{"parsable", 0, 0, 'p'},
{"parsable2",0, 0, 'P'},
{"users", 1, 0, 'u'},
{"verbose", 0, 0, 'v'},
{"version", 0, 0, 'V'},
{"help", 0, 0, OPT_LONG_HELP},
{"usage", 0, 0, OPT_LONG_USAGE},
{NULL, 0, 0, 0}
};
exit_code = 0;
long_flag = 0;
quiet_flag = 0;
verbosity = 0;
memset(&req_msg, 0, sizeof(shares_request_msg_t));
log_init("sshare", opts, SYSLOG_FACILITY_DAEMON, NULL);
while((opt_char = getopt_long(argc, argv, "aA:hlM:npPqu:t:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"sshare --help\" "
"for more information\n");
exit(1);
break;
case 'a':
all_users = 1;
break;
case 'A':
if(!req_msg.acct_list)
req_msg.acct_list =
list_create(slurm_destroy_char);
slurm_addto_char_list(req_msg.acct_list, optarg);
break;
case 'h':
print_fields_have_header = 0;
break;
exit(exit_code);
break;
case 'l':
long_flag = 1;
break;
case 'M':
if(clusters)
list_destroy(clusters);
if(!(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(clusters);
break;
case 'n':
print_fields_have_header = 0;
break;
case 'p':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_ENDING;
break;
case 'P':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_NO_ENDING;
break;
case 'u':
if(!strcmp(optarg, "-1")) {
all_users = 1;
break;
}
all_users = 0;
if(!req_msg.user_list)
req_msg.user_list =
list_create(slurm_destroy_char);
_addto_name_char_list(req_msg.user_list, optarg, 0);
break;
case 'v':
quiet_flag = -1;
verbosity++;
break;
case 'V':
_print_version();
exit(exit_code);
break;
case OPT_LONG_HELP:
case OPT_LONG_USAGE:
_usage();
exit(0);
default:
exit_code = 1;
fprintf(stderr, "getopt error, returned %c\n",
opt_char);
exit(exit_code);
}
}
if (verbosity) {
opts.stderr_level += verbosity;
opts.prefix_level = 1;
log_alter(opts, 0, NULL);
}
if(all_users) {
if(req_msg.user_list
&& list_count(req_msg.user_list)) {
list_destroy(req_msg.user_list);
req_msg.user_list = NULL;
}
if(verbosity)
fprintf(stderr, "Users requested:\n\t: all\n");
} else if (verbosity && req_msg.user_list
&& list_count(req_msg.user_list)) {
fprintf(stderr, "Users requested:\n");
ListIterator itr = list_iterator_create(req_msg.user_list);
while((temp = list_next(itr)))
fprintf(stderr, "\t: %s\n", temp);
list_iterator_destroy(itr);
} else if(!req_msg.user_list || !list_count(req_msg.user_list)) {
struct passwd *pwd = getpwuid(getuid());
if(!req_msg.user_list)
req_msg.user_list = list_create(slurm_destroy_char);
temp = xstrdup(pwd->pw_name);
list_append(req_msg.user_list, temp);
if(verbosity) {
fprintf(stderr, "Users requested:\n");
fprintf(stderr, "\t: %s\n", temp);
}
}
if(req_msg.acct_list && list_count(req_msg.acct_list)) {
fprintf(stderr, "Accounts requested:\n");
ListIterator itr = list_iterator_create(req_msg.acct_list);
while((temp = list_next(itr)))
fprintf(stderr, "\t: %s\n", temp);
list_iterator_destroy(itr);
} else {
if(req_msg.acct_list
&& list_count(req_msg.acct_list)) {
list_destroy(req_msg.acct_list);
req_msg.acct_list = NULL;
}
if(verbosity)
fprintf(stderr, "Accounts requested:\n\t: all\n");
}
error_code = _get_info(&req_msg, &resp_msg);
if(req_msg.acct_list)
list_destroy(req_msg.acct_list);
if(req_msg.user_list)
list_destroy(req_msg.user_list);
if (error_code) {
slurm_perror("Couldn't get shares from controller");
exit(error_code);
}
/* do stuff with it */
process(resp_msg);
slurm_free_shares_response_msg(resp_msg);
exit(exit_code);
}
int
main (int argc, char **argv)
{
int error_code = SLURM_SUCCESS, i, opt_char, input_field_count;
char **input_fields;
log_options_t opts = LOG_OPTS_STDERR_ONLY ;
char *temp = NULL;
int option_index;
static struct option long_options[] = {
{"all_clusters", 0, 0, 'a'},
{"cluster", 1, 0, 'M'},
{"help", 0, 0, 'h'},
{"immediate",0, 0, 'i'},
{"noheader", 0, 0, 'n'},
{"parsable", 0, 0, 'p'},
{"parsable2",0, 0, 'P'},
{"quiet", 0, 0, 'Q'},
{"sort", 0, 0, 's'},
{"tres", 1, 0, 'T'},
{"usage", 0, 0, 'h'},
{"verbose", 0, 0, 'v'},
{"version", 0, 0, 'V'},
{NULL, 0, 0, 0}
};
command_name = argv[0];
exit_code = 0;
exit_flag = 0;
input_field_count = 0;
quiet_flag = 0;
slurm_conf_init(NULL);
log_init("sreport", opts, SYSLOG_FACILITY_DAEMON, NULL);
/* Check to see if we are running a supported accounting plugin */
temp = slurm_get_accounting_storage_type();
if (xstrcasecmp(temp, "accounting_storage/slurmdbd")
&& xstrcasecmp(temp, "accounting_storage/mysql")) {
fprintf (stderr, "You are not running a supported "
"accounting_storage plugin\n(%s).\n"
"Only 'accounting_storage/slurmdbd' "
"and 'accounting_storage/mysql' are supported.\n",
temp);
xfree(temp);
exit(1);
}
xfree(temp);
temp = getenv("SREPORT_TRES");
if (temp)
tres_str = xstrdup(temp);
while ((opt_char = getopt_long(argc, argv, "aM:hnpPQs:t:T:vV",
long_options, &option_index)) != -1) {
switch (opt_char) {
case (int)'?':
fprintf(stderr, "Try \"sreport --help\" "
"for more information\n");
exit(1);
break;
case (int)'h':
_usage ();
exit(exit_code);
break;
case (int)'a':
all_clusters_flag = 1;
break;
case (int) 'M':
cluster_flag = xstrdup(optarg);
break;
case (int)'n':
print_fields_have_header = 0;
break;
case (int)'p':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_ENDING;
break;
case (int)'P':
print_fields_parsable_print =
PRINT_FIELDS_PARSABLE_NO_ENDING;
break;
case (int)'Q':
quiet_flag = 1;
break;
case (int)'s':
_set_sort(optarg);
break;
case (int)'t':
_set_time_format(optarg);
break;
case (int)'T':
xfree(tres_str);
tres_str = xstrdup(optarg);
break;
case (int)'v':
quiet_flag = -1;
break;
case (int)'V':
_print_version();
exit(exit_code);
break;
default:
exit_code = 1;
fprintf(stderr, "getopt error, returned %c\n",
opt_char);
exit(exit_code);
}
}
if (argc > MAX_INPUT_FIELDS) /* bogus input, but continue anyway */
input_words = argc;
else
input_words = 128;
input_fields = (char **) xmalloc (sizeof (char *) * input_words);
if (optind < argc) {
for (i = optind; i < argc; i++) {
input_fields[input_field_count++] = argv[i];
}
}
my_uid = getuid();
db_conn = slurmdb_connection_get();
if (errno) {
fatal("Problem connecting to the database: %m");
exit(1);
}
tres_list = _build_tres_list(tres_str);
if (input_field_count)
exit_flag = 1;
else
error_code = _get_command (&input_field_count, input_fields);
while (error_code == SLURM_SUCCESS) {
error_code = _process_command (input_field_count,
input_fields);
if (error_code || exit_flag)
break;
error_code = _get_command (&input_field_count, input_fields);
}
if (exit_flag == 2)
putchar('\n');
/* Free the cluster grabbed from the -M option */
xfree(cluster_flag);
slurmdb_connection_close(&db_conn);
slurm_acct_storage_fini();
exit(exit_code);
}
/*
* _process_command - process the user's command
* IN argc - count of arguments
* IN argv - the arguments
* RET 0 or errno (only for errors fatal to sreport)
*/
static int
_process_command (int argc, char **argv)
{
int command_len = 0;
if (argc < 1) {
exit_code = 1;
if (quiet_flag == -1)
fprintf(stderr, "no input");
return 0;
}
command_len = strlen(argv[0]);
if ((strncasecmp (argv[0], "association", MAX(command_len, 1)) == 0)) {
if (argc < 2) {
exit_code = 1;
if (quiet_flag != 1)
fprintf(stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_assoc_rep((argc - 1), &argv[1]);
} else if ((strncasecmp (argv[0], "cluster",
MAX(command_len, 2)) == 0)) {
if (argc < 2) {
exit_code = 1;
if (quiet_flag != 1)
fprintf(stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_cluster_rep((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "help", MAX(command_len, 2)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for keyword:%s\n",
argv[0]);
}
_usage ();
} else if ((strncasecmp (argv[0], "job", MAX(command_len, 1)) == 0)) {
if (argc < 2) {
exit_code = 1;
if (quiet_flag != 1)
fprintf(stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_job_rep((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "quiet", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr, "too many arguments for keyword:%s\n",
argv[0]);
}
quiet_flag = 1;
} else if ((strncasecmp (argv[0], "exit", MAX(command_len, 1)) == 0) ||
(strncasecmp (argv[0], "\\q", MAX(command_len, 2)) == 0) ||
(strncasecmp (argv[0], "quit", MAX(command_len, 4)) == 0)) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for keyword:%s\n",
argv[0]);
}
exit_flag = 1;
} else if (strncasecmp (argv[0], "nonparsable",
MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr, "too many arguments for keyword:%s\n",
argv[0]);
}
print_fields_parsable_print = 0;
} else if (strncasecmp (argv[0], "parsable",
MAX(command_len, 8)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr, "too many arguments for keyword:%s\n",
argv[0]);
}
print_fields_parsable_print = PRINT_FIELDS_PARSABLE_ENDING;
} else if (strncasecmp (argv[0], "parsable2",
MAX(command_len, 9)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr, "too many arguments for keyword:%s\n",
argv[0]);
}
print_fields_parsable_print = PRINT_FIELDS_PARSABLE_NO_ENDING;
} else if ((strncasecmp (argv[0], "reservation",
MAX(command_len, 2)) == 0)
|| (strncasecmp (argv[0], "resv",
MAX(command_len, 2)) == 0)) {
if (argc < 2) {
exit_code = 1;
if (quiet_flag != 1)
fprintf(stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_resv_rep((argc - 1), &argv[1]);
} else if (strncasecmp (argv[0], "sort", MAX(command_len, 1)) == 0) {
if (argc < 2) {
exit_code = 1;
fprintf (stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_set_sort(argv[1]);
} else if (strncasecmp (argv[0], "time", MAX(command_len, 1)) == 0) {
if (argc < 2) {
exit_code = 1;
fprintf (stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_set_time_format(argv[1]);
} else if (strncasecmp (argv[0], "verbose", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
quiet_flag = -1;
} else if (strncasecmp (argv[0], "version", MAX(command_len, 4)) == 0) {
if (argc > 1) {
exit_code = 1;
fprintf (stderr,
"too many arguments for %s keyword\n",
argv[0]);
}
_print_version();
} else if ((strncasecmp (argv[0], "user", MAX(command_len, 1)) == 0)) {
if (argc < 2) {
exit_code = 1;
if (quiet_flag != 1)
fprintf(stderr,
"too few arguments for keyword:%s\n",
argv[0]);
} else
_user_rep((argc - 1), &argv[1]);
} else {
exit_code = 1;
fprintf (stderr, "invalid keyword: %s\n", argv[0]);
}
return 0;
}
static void
_process_options(struct ld *ld, int key, char *arg)
{
struct ld_state *ls;
assert(ld != NULL);
ls = &ld->ld_state;
switch (key) {
case 'b':
ls->ls_itgt = elftc_bfd_find_target(arg);
if (ls->ls_itgt == NULL)
ld_fatal(ld, "invalid BFD target `%s'", arg);
break;
case 'd':
ld->ld_common_alloc = 1;
break;
case 'e':
_copy_optarg(ld, &ld->ld_entry, arg);
break;
case 'h':
_copy_optarg(ld, &ld->ld_soname, arg);
break;
case 'I':
_copy_optarg(ld, &ld->ld_interp, arg);
break;
case 'l':
ld_path_search_library(ld, arg);
break;
case 'L':
ld_path_add(ld, arg);
break;
case 'M':
ld->ld_print_linkmap = 1;
break;
case 'o':
_copy_optarg(ld, &ld->ld_output_file, arg);
break;
case 'q':
ld->ld_emit_reloc = 1;
break;
case 'r':
ld->ld_reloc = 1;
break;
case 'T':
ld_script_parse(arg);
break;
case 'u':
ld_symbols_add_extern(ld, arg);
break;
case 'v':
case 'V':
_print_version(ld);
break;
case '(':
ls->ls_group_level++;
if (ls->ls_group_level > LD_MAX_NESTED_GROUP)
ld_fatal(ld, "too many nested archive groups");
break;
case ')':
ls->ls_group_level--;
break;
case KEY_AS_NEEDED:
ls->ls_as_needed = 1;
break;
case KEY_DYNAMIC:
ls->ls_static = 0;
break;
case KEY_EH_FRAME_HDR:
ld->ld_ehframe_hdr = 1;
break;
case KEY_GC_SECTIONS:
ld->ld_gc = 1;
break;
case KEY_NO_AS_NEEDED:
ls->ls_as_needed = 0;
break;
case KEY_NO_DEFINE_COMMON:
ld->ld_common_no_alloc = 1;
break;
case KEY_NO_GC_SECTIONS:
ld->ld_gc = 0;
break;
case KEY_NO_PRINT_GC_SECTIONS:
ld->ld_gc_print = 0;
break;
case KEY_NO_WHOLE_ARCHIVE:
ls->ls_whole_archive = 0;
break;
case KEY_OFORMAT:
ld_output_format(ld, arg, arg, arg);
break;
case KEY_PIE:
ld->ld_exec = 0;
ld->ld_pie = 1;
ld->ld_dynamic_link = 1;
break;
case KEY_PRINT_GC_SECTIONS:
ld->ld_gc_print = 1;
break;
case KEY_SHARED:
ld->ld_exec = 0;
ld->ld_dso = 1;
ld->ld_dynamic_link = 1;
break;
case KEY_STATIC:
ls->ls_static = 1;
break;
case KEY_WHOLE_ARCHIVE:
ls->ls_whole_archive = 1;
break;
case KEY_FILE:
ld_file_add(ld, arg, LFT_UNKNOWN);
break;
case KEY_VERSION_SCRIPT:
ld_script_parse(arg);
break;
case KEY_Z_EXEC_STACK:
ld->ld_gen_gnustack = 1;
ld->ld_stack_exec_set = 1;
ld->ld_stack_exec = 1;
break;
case KEY_Z_NO_EXEC_STACK:
ld->ld_gen_gnustack = 1;
ld->ld_stack_exec_set = 1;
ld->ld_stack_exec = 0;
break;
default:
break;
}
}
/* We need this */
int main(int argc, char *argv[]) {
int optc, show_help, show_version, show_usage;
char *local_file, *cmd_listen_port, *cmd_pid_file;
int inetd_mode, no_daemon;
/* Set up some globals */
progname = argv[0];
listen_port = x_strdup(DEFAULT_LISTEN_PORT);
pid_file = (DEFAULT_PID_FILE ? x_strdup(DEFAULT_PID_FILE) : 0);
#ifndef DEBUG
no_daemon = 0;
#else /* DEBUG */
no_daemon = 1;
#endif /* DEBUG */
local_file = cmd_listen_port = cmd_pid_file = 0;
show_help = show_version = show_usage = inetd_mode = 0;
while ((optc = getopt_long(argc, argv, GETOPTIONS, long_opts, NULL)) != -1) {
switch (optc) {
case 'h':
show_help = 1;
break;
case 'v':
show_version = 1;
break;
case 'D':
#ifndef DEBUG
no_daemon = 1;
#else /* DEBUG */
no_daemon = 0;
#endif /* DEBUG */
break;
case 'I':
inetd_mode = 1;
break;
case 'P':
free(cmd_listen_port);
cmd_listen_port = x_strdup(optarg);
break;
case 'p':
free(cmd_pid_file);
cmd_pid_file = x_strdup(optarg);
break;
case 'f':
free(local_file);
local_file = x_strdup(optarg);
break;
default:
show_usage = 1;
break;
}
}
if (show_usage || (optind < argc)) {
_print_usage();
return 1;
}
if (show_version) {
_print_version();
if (!show_help)
return 0;
}
if (show_help) {
_print_help();
return 0;
}
/* If no -f was specified use the home directory */
if (!local_file && !inetd_mode) {
struct stat statinfo;
struct passwd *pw;
pw = getpwuid(geteuid());
if (pw && pw->pw_dir) {
local_file = x_sprintf("%s/%s", pw->pw_dir, USER_CONFIG_FILENAME);
debug("Local config file: %s", local_file);
if (!stat(local_file, &statinfo) && (statinfo.st_mode & 0077)) {
fprintf(stderr, "%s: Permissions of %s must be 0700 or "
"more restrictive\n", progname, local_file);
free(local_file);
return 2;
}
if (cfg_read(local_file, &listen_port, &pid_file, &g)) {
/* If the local one didn't exist, set to 0 so we open
global one */
free(local_file);
local_file = 0;
} else {
config_file = x_strdup(local_file);
}
}
} else if (local_file) {
if (cfg_read(local_file, &listen_port, &pid_file, &g)) {
/* This is fatal! */
fprintf(stderr, "%s: Couldn't read configuration from %s: %s\n",
progname, local_file, strerror(errno));
free(local_file);
return 2;
} else {
config_file = x_strdup(local_file);
}
}
/* Read global config file if local one not found */
if (!local_file) {
char *global_file;
/* Not fatal if it doesn't exist */
global_file = x_sprintf("%s/%s", SYSCONFDIR, GLOBAL_CONFIG_FILENAME);
debug("Global config file: %s", global_file);
cfg_read(global_file, &listen_port, &pid_file, &g);
config_file = x_strdup(global_file);
free(global_file);
} else {
free(local_file);
}
/* Check we got some connection classes */
if (!connclasses) {
fprintf(stderr, "%s: No connection classes have been defined.\n", progname);
return 2;
}
/* -P overrides config file */
if (cmd_listen_port) {
free(listen_port);
listen_port = cmd_listen_port;
}
/* -p overrides pid file */
if (cmd_pid_file) {
free(pid_file);
pid_file = cmd_pid_file;
}
/* Set signal handlers */
signal(SIGTERM, _sig_term);
signal(SIGINT, _sig_term);
signal(SIGHUP, _sig_hup);
signal(SIGCHLD, _sig_child);
#ifdef DEBUG_MEMORY
signal(SIGUSR1, _sig_usr);
signal(SIGUSR2, _sig_usr);
#endif /* DEBUG_MEMORY */
/* Broken Pipe? This means that someone disconnected while we were
sending stuff. Naughty! */
signal(SIGPIPE, SIG_IGN);
if (!inetd_mode) {
debug("Ordinary console dodge-monkey mode");
/* Make listening socket before we fork */
if (ircnet_listen(listen_port)) {
fprintf(stderr, "%s: Unable to establish listen port\n", progname);
return 3;
}
/* go daemon here */
if (!no_daemon) {
switch (go_daemon()) {
case -1:
return -1;
case 0:
break;
default:
return 0;
}
}
} else {
/* running under inetd means we are backgrounded right *now* */
in_background = 1;
debug("Inetd SuperTed mode!");
/* Hook STDIN into a new proxy */
ircnet_hooksocket(STDIN_FILENO);
}
/* Open a connection to syslog if we're in the background */
if (in_background)
openlog(PACKAGE, LOG_PID, LOG_USER);
if (pid_file) {
FILE *pidfile;
pidfile = fopen(pid_file, "w");
if (pidfile) {
fchmod(fileno(pidfile), 0600);
fprintf(pidfile, "%d\n", getpid());
fclose(pidfile);
} else {
syscall_fail("fopen", pid_file, 0);
}
}
/* Main loop! */
while (!stop_poll) {
int ns, nt, status;
pid_t pid;
ircnet_expunge_proxies();
dccnet_expunge_proxies();
ns = net_poll();
nt = timer_poll();
/* Reap any children */
while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
debug("Reaped process %d, exit status %d", pid, status);
/* Handle any DNS children */
dns_endrequest(pid, status);
}
/* Reload the configuration file? */
if (reload_config) {
_reload_config();
reload_config = 0;
}
if (!ns && !nt)
break;
}
if (pid_file) {
unlink(pid_file);
}
/* Free up stuff */
ircnet_flush();
dccnet_flush();
dns_flush();
timer_flush();
/* Do a lingering close on all sockets */
net_closeall();
net_flush();
/* Close down and free up memory */
if (!inetd_mode && !no_daemon)
closelog();
free(listen_port);
free(pid_file);
free(config_file);
#ifdef DEBUG_MEMORY
mem_report("termination");
#endif /* DEBUG_MEMORY */
return 0;
}