extern int sacctmgr_delete_cluster(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
slurmdb_cluster_cond_t *cluster_cond =
xmalloc(sizeof(slurmdb_cluster_cond_t));
int i=0;
List ret_list = NULL;
int cond_set = 0, prev_set;
slurmdb_init_cluster_cond(cluster_cond, 0);
cluster_cond->cluster_list = list_create(slurm_destroy_char);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
prev_set = _set_cond(&i, argc, argv, cluster_cond, NULL);
cond_set |= prev_set;
}
if (exit_code) {
slurmdb_destroy_cluster_cond(cluster_cond);
return SLURM_ERROR;
} else if (!cond_set) {
exit_code=1;
fprintf(stderr,
" No conditions given to remove, not executing.\n");
slurmdb_destroy_cluster_cond(cluster_cond);
return SLURM_ERROR;
}
if (!list_count(cluster_cond->cluster_list)
&& !cluster_cond->classification
&& (!cluster_cond->federation_list ||
!list_count(cluster_cond->federation_list))) {
exit_code=1;
fprintf(stderr,
"problem with delete request. "
"Nothing given to delete.\n");
slurmdb_destroy_cluster_cond(cluster_cond);
return SLURM_SUCCESS;
}
notice_thread_init();
ret_list = acct_storage_g_remove_clusters(
db_conn, my_uid, cluster_cond);
rc = errno;
notice_thread_fini();
slurmdb_destroy_cluster_cond(cluster_cond);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
/* If there were jobs running with an association to
be deleted, don't.
*/
if (rc == ESLURM_JOBS_RUNNING_ON_ASSOC) {
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(rc));
while((object = list_next(itr))) {
fprintf(stderr," %s\n", object);
}
FREE_NULL_LIST(ret_list);
acct_storage_g_commit(db_conn, 0);
return rc;
}
printf(" Deleting clusters...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else if (ret_list) {
printf(" Nothing deleted\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
return rc;
}
extern int sacctmgr_add_cluster(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
int i = 0;
slurmdb_cluster_rec_t *cluster = NULL;
slurmdb_cluster_rec_t *start_cluster =
xmalloc(sizeof(slurmdb_cluster_rec_t));
List name_list = list_create(slurm_destroy_char);
List cluster_list = NULL;
slurmdb_assoc_rec_t start_assoc;
int limit_set = 0;
ListIterator itr = NULL, itr_c = NULL;
char *name = NULL;
slurmdb_init_assoc_rec(&start_assoc, 0);
slurmdb_init_cluster_rec(start_cluster, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_rec(&i, argc, argv,
name_list, &start_assoc, start_cluster);
}
if (exit_code) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
} else if (!list_count(name_list)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
exit_code=1;
fprintf(stderr, " Need name of cluster to add.\n");
return SLURM_ERROR;
} else {
List temp_list = NULL;
slurmdb_cluster_cond_t cluster_cond;
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.cluster_list = name_list;
cluster_cond.classification = start_cluster->classification;
temp_list = acct_storage_g_get_clusters(db_conn, my_uid,
&cluster_cond);
if (!temp_list) {
exit_code=1;
fprintf(stderr,
" Problem getting clusters from database. "
"Contact your admin.\n");
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
}
itr_c = list_iterator_create(name_list);
itr = list_iterator_create(temp_list);
while((name = list_next(itr_c))) {
slurmdb_cluster_rec_t *cluster_rec = NULL;
list_iterator_reset(itr);
while((cluster_rec = list_next(itr))) {
if (!xstrcasecmp(cluster_rec->name, name))
break;
}
if (cluster_rec) {
printf(" This cluster %s already exists. "
"Not adding.\n", name);
list_delete_item(itr_c);
}
}
list_iterator_destroy(itr);
list_iterator_destroy(itr_c);
FREE_NULL_LIST(temp_list);
if (!list_count(name_list)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_cluster_rec(start_cluster);
return SLURM_ERROR;
}
}
if (start_cluster->fed.name) {
int rc;
List fed_list = list_create(slurm_destroy_char);
list_append(fed_list, xstrdup(start_cluster->fed.name));
rc = verify_federations_exist(fed_list);
FREE_NULL_LIST(fed_list);
if (rc) {
slurmdb_destroy_cluster_rec(start_cluster);
FREE_NULL_LIST(name_list);
return SLURM_ERROR;
}
}
printf(" Adding Cluster(s)\n");
cluster_list = list_create(slurmdb_destroy_cluster_rec);
itr = list_iterator_create(name_list);
while((name = list_next(itr))) {
if (!name[0]) {
exit_code=1;
fprintf(stderr, " No blank names are "
"allowed when adding.\n");
rc = SLURM_ERROR;
continue;
}
cluster = xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_init_cluster_rec(cluster, 0);
list_append(cluster_list, cluster);
slurmdb_copy_cluster_rec(cluster, start_cluster);
cluster->name = xstrdup(name);
printf(" Name = %s\n", cluster->name);
cluster->root_assoc =
xmalloc(sizeof(slurmdb_assoc_rec_t));
slurmdb_init_assoc_rec(cluster->root_assoc, 0);
cluster->root_assoc->def_qos_id = start_assoc.def_qos_id;
cluster->root_assoc->shares_raw = start_assoc.shares_raw;
slurmdb_copy_assoc_rec_limits(
cluster->root_assoc, &start_assoc);
}
list_iterator_destroy(itr);
FREE_NULL_LIST(name_list);
if (limit_set)
printf(" Setting\n");
if (limit_set & CLUS_REC_SET)
sacctmgr_print_cluster(start_cluster);
if (limit_set & CLUS_ASSOC_SET) {
printf(" Default Limits:\n");
sacctmgr_print_assoc_limits(&start_assoc);
FREE_NULL_LIST(start_assoc.qos_list);
}
slurmdb_destroy_cluster_rec(start_cluster);
if (!list_count(cluster_list)) {
printf(" Nothing new added.\n");
rc = SLURM_ERROR;
goto end_it;
}
/* Since we are creating tables with add cluster that can't be
rolled back. So we ask before hand if they are serious
about it so we can rollback if needed.
*/
if (commit_check("Would you like to commit changes?")) {
notice_thread_init();
rc = acct_storage_g_add_clusters(db_conn, my_uid, cluster_list);
notice_thread_fini();
if (rc == SLURM_SUCCESS) {
acct_storage_g_commit(db_conn, 1);
} else {
exit_code=1;
fprintf(stderr, " Problem adding clusters: %s\n",
slurm_strerror(rc));
/* this isn't really needed, but just to be safe */
acct_storage_g_commit(db_conn, 0);
}
} else {
printf(" Changes Discarded\n");
/* this isn't really needed, but just to be safe */
acct_storage_g_commit(db_conn, 0);
}
end_it:
FREE_NULL_LIST(cluster_list);
return rc;
}
extern int sacctmgr_modify_cluster(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
int i=0;
slurmdb_cluster_rec_t *cluster =
xmalloc(sizeof(slurmdb_cluster_rec_t));
slurmdb_assoc_rec_t *assoc =
xmalloc(sizeof(slurmdb_assoc_rec_t));
slurmdb_assoc_cond_t *assoc_cond =
xmalloc(sizeof(slurmdb_assoc_cond_t));
int cond_set = 0, prev_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
slurmdb_cluster_cond_t cluster_cond;
bool existing_fed = false;
slurmdb_init_assoc_rec(assoc, 0);
assoc_cond->cluster_list = list_create(slurm_destroy_char);
assoc_cond->acct_list = list_create(NULL);
slurmdb_init_cluster_rec(cluster, 0);
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.cluster_list = assoc_cond->cluster_list;
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
prev_set = _set_cond(&i, argc, argv,
&cluster_cond, NULL);
cond_set |= prev_set;
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
prev_set = _set_rec(&i, argc, argv,
NULL, assoc, cluster);
rec_set |= prev_set;
} else {
prev_set = _set_cond(&i, argc, argv,
&cluster_cond, NULL);
cond_set |= prev_set;
}
}
if (exit_code) {
rc = SLURM_ERROR;
goto end_it;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
rc = SLURM_ERROR;
goto end_it;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions with 'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
rc = SLURM_SUCCESS;
goto end_it;
}
}
if (cluster->fed.name && cluster->fed.name[0]) {
int rc;
/* Make sure federation exists. */
List fed_list = list_create(slurm_destroy_char);
list_append(fed_list, xstrdup(cluster->fed.name));
rc = verify_federations_exist(fed_list);
FREE_NULL_LIST(fed_list);
if (rc)
goto end_it;
/* See if cluster is assigned to another federation already. */
if (list_count(cluster_cond.cluster_list)) {
if (_verify_fed_clusters(cluster_cond.cluster_list,
cluster->fed.name,
&existing_fed))
goto end_it;
else if (!list_count(cluster_cond.cluster_list)) {
/* irrelevant changes have been removed and
* nothing to change now. */
printf("Nothing to change\n");
rc = SLURM_ERROR;
(void)rc; /* CLANG false positive */
goto end_it;
} else if (existing_fed) {
char *warning =
"\nAre you sure you want to continue?";
if (!commit_check(warning)) {
rc = SLURM_ERROR;
(void)rc; /* CLANG false positive */
goto end_it;
}
}
}
}
if (cond_set & 1) {
List temp_list = NULL;
temp_list = acct_storage_g_get_clusters(db_conn, my_uid,
&cluster_cond);
if (!temp_list) {
exit_code=1;
fprintf(stderr,
" Problem getting clusters from database. "
"Contact your admin.\n");
rc = SLURM_ERROR;
goto end_it;
} else if (!list_count(temp_list)) {
fprintf(stderr,
" Query didn't return any clusters.\n");
rc = SLURM_ERROR;
goto end_it;
}
/* we are only looking for the clusters returned from
this query, so we free the cluster_list and replace
it */
FREE_NULL_LIST(assoc_cond->cluster_list);
assoc_cond->cluster_list = temp_list;
}
printf(" Setting\n");
if (rec_set & CLUS_REC_SET)
sacctmgr_print_cluster(cluster);
if (rec_set & CLUS_ASSOC_SET) {
printf(" Default Limits:\n");
sacctmgr_print_assoc_limits(assoc);
}
if (rec_set & CLUS_REC_SET) {
notice_thread_init();
ret_list = acct_storage_g_modify_clusters(
db_conn, my_uid, &cluster_cond, cluster);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified cluster...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
notice_thread_fini();
}
if (rec_set & CLUS_ASSOC_SET) {
list_append(assoc_cond->acct_list, "root");
notice_thread_init();
ret_list = acct_storage_g_modify_assocs(db_conn, my_uid,
assoc_cond, assoc);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified cluster defaults for "
"associations...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
notice_thread_fini();
}
if (set) {
if (commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
end_it:
slurmdb_destroy_assoc_cond(assoc_cond);
slurmdb_destroy_assoc_rec(assoc);
slurmdb_destroy_cluster_rec(cluster);
return rc;
}
extern int sacctmgr_modify_res(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_res_cond_t *res_cond =
xmalloc(sizeof(slurmdb_res_cond_t));
slurmdb_res_rec_t *res =
xmalloc(sizeof(slurmdb_res_rec_t));
int i=0;
int cond_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
slurmdb_init_res_cond(res_cond, 0);
slurmdb_init_res_rec(res, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
cond_set += _set_res_cond(&i, argc, argv,
res_cond, NULL);
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
rec_set += _set_res_rec(&i, argc, argv,
NULL, NULL, res);
} else {
cond_set += _set_res_cond(&i, argc, argv,
res_cond, NULL);
}
}
if (exit_code) {
slurmdb_destroy_res_cond(res_cond);
slurmdb_destroy_res_rec(res);
return SLURM_ERROR;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
slurmdb_destroy_res_cond(res_cond);
slurmdb_destroy_res_rec(res);
return SLURM_ERROR;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions with "
"'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
slurmdb_destroy_res_cond(res_cond);
slurmdb_destroy_res_rec(res);
return SLURM_SUCCESS;
}
}
notice_thread_init();
ret_list = acct_storage_g_modify_res(db_conn, my_uid, res_cond, res);
notice_thread_fini();
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified server resource ...\n");
while ((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else if (errno == ESLURM_OVER_ALLOCATE) {
exit_code=1;
rc = SLURM_ERROR;
fprintf(stderr,
" If change was accepted it would look like this...\n");
_print_overcommit(res, res_cond);
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if (set) {
if (commit_check("Would you like to commit changes?")){
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
FREE_NULL_LIST(ret_list);
slurmdb_destroy_res_cond(res_cond);
slurmdb_destroy_res_rec(res);
return rc;
}
extern int sacctmgr_delete_res(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_res_cond_t *res_cond = xmalloc(sizeof(slurmdb_res_cond_t));
int i=0;
List ret_list = NULL;
ListIterator itr = NULL;
int set = 0;
char *name = NULL;
slurmdb_init_res_cond(res_cond, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
set += _set_res_cond(&i, argc, argv, res_cond, NULL);
}
if (!set) {
exit_code=1;
fprintf(stderr,
" No conditions given to remove, not executing.\n");
slurmdb_destroy_res_cond(res_cond);
return SLURM_ERROR;
} else if (set == -1) {
slurmdb_destroy_res_cond(res_cond);
return SLURM_ERROR;
}
notice_thread_init();
ret_list = acct_storage_g_remove_res(db_conn, my_uid, res_cond);
notice_thread_fini();
slurmdb_destroy_res_cond(res_cond);
if (ret_list && list_count(ret_list)) {
itr = list_iterator_create(ret_list);
printf(" Deleting resource(s)...\n");
while ((name = list_next(itr))) {
printf(" %s\n", name);
}
list_iterator_destroy(itr);
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else if (ret_list) {
printf(" Nothing deleted\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
xfree(name);
return rc;
}
extern int sacctmgr_modify_account(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_account_cond_t *acct_cond =
xmalloc(sizeof(slurmdb_account_cond_t));
slurmdb_account_rec_t *acct = xmalloc(sizeof(slurmdb_account_rec_t));
slurmdb_association_rec_t *assoc =
xmalloc(sizeof(slurmdb_association_rec_t));
int i=0;
int cond_set = 0, prev_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
slurmdb_init_association_rec(assoc, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
prev_set = _set_cond(&i, argc, argv, acct_cond, NULL);
cond_set |= prev_set;
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
prev_set = _set_rec(&i, argc, argv, NULL, NULL,
acct, assoc);
rec_set |= prev_set;
} else {
prev_set = _set_cond(&i, argc, argv, acct_cond, NULL);
cond_set |= prev_set;
}
}
if (exit_code) {
slurmdb_destroy_account_cond(acct_cond);
slurmdb_destroy_account_rec(acct);
slurmdb_destroy_association_rec(assoc);
return SLURM_ERROR;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
slurmdb_destroy_account_cond(acct_cond);
slurmdb_destroy_account_rec(acct);
slurmdb_destroy_association_rec(assoc);
return SLURM_ERROR;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions with 'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
slurmdb_destroy_account_cond(acct_cond);
slurmdb_destroy_account_rec(acct);
slurmdb_destroy_association_rec(assoc);
return SLURM_SUCCESS;
}
}
// Special case: reset raw usage only
if (assoc->usage) {
rc = SLURM_ERROR;
if (assoc->usage->usage_raw == 0.0)
rc = sacctmgr_remove_assoc_usage(acct_cond->assoc_cond);
else
error("Raw usage can only be set to 0 (zero)");
slurmdb_destroy_account_cond(acct_cond);
slurmdb_destroy_account_rec(acct);
slurmdb_destroy_association_rec(assoc);
return rc;
}
notice_thread_init();
if (rec_set & 1) { // process the account changes
if (cond_set == 2) {
exit_code=1;
fprintf(stderr,
" There was a problem with your "
"'where' options.\n");
rc = SLURM_ERROR;
goto assoc_start;
}
ret_list = acct_storage_g_modify_accounts(
db_conn, my_uid, acct_cond, acct);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified accounts...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if (ret_list)
list_destroy(ret_list);
}
assoc_start:
if (rec_set == 3 || rec_set == 2) { // process the association changes
if (cond_set == 1 && !acct_cond->assoc_cond->acct_list) {
rc = SLURM_ERROR;
exit_code=1;
fprintf(stderr,
" There was a problem with your "
"'where' options.\n");
goto assoc_end;
}
if (assoc->parent_acct) {
slurmdb_account_rec_t *acct_rec =
sacctmgr_find_account(assoc->parent_acct);
if (!acct_rec) {
exit_code=1;
fprintf(stderr,
" Parent Account %s doesn't exist.\n",
assoc->parent_acct);
rc = SLURM_ERROR;
goto assoc_end;
}
}
ret_list = acct_storage_g_modify_associations(
db_conn, my_uid, acct_cond->assoc_cond, assoc);
if (ret_list && list_count(ret_list)) {
set = 1;
if (assoc->def_qos_id != NO_VAL)
set = sacctmgr_check_default_qos(
assoc->def_qos_id,
acct_cond->assoc_cond);
else if (assoc->qos_list)
set = sacctmgr_check_default_qos(
-1, acct_cond->assoc_cond);
if (set) {
char *object = NULL;
ListIterator itr = list_iterator_create(
ret_list);
printf(" Modified account associations...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
}
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if (ret_list)
list_destroy(ret_list);
}
assoc_end:
notice_thread_fini();
if (set) {
if (commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
slurmdb_destroy_account_cond(acct_cond);
slurmdb_destroy_account_rec(acct);
slurmdb_destroy_association_rec(assoc);
return rc;
}
extern int sacctmgr_add_res(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
int i=0, limit_set=0;
ListIterator itr = NULL;
ListIterator clus_itr = NULL;
slurmdb_res_rec_t *res = NULL;
slurmdb_res_rec_t *found_res = NULL;
slurmdb_res_rec_t *start_res = xmalloc(sizeof(slurmdb_res_rec_t));
List cluster_list = list_create(slurm_destroy_char);
List name_list = list_create(slurm_destroy_char);
char *name = NULL;
List res_list = NULL;
char *res_str = NULL;
slurmdb_init_res_rec(start_res, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_res_rec(&i, argc, argv, name_list,
cluster_list, start_res);
}
if (exit_code) {
FREE_NULL_LIST(name_list);
FREE_NULL_LIST(cluster_list);
slurmdb_destroy_res_rec(start_res);
return SLURM_ERROR;
} else if (!list_count(name_list)) {
FREE_NULL_LIST(name_list);
FREE_NULL_LIST(cluster_list);
slurmdb_destroy_res_rec(start_res);
exit_code=1;
fprintf(stderr, " Need name of resource to add.\n");
return SLURM_SUCCESS;
}
if (!start_res->server) {
/* assign some server name */
start_res->server = xstrdup("slurmdb");
}
if (!g_res_list) {
slurmdb_res_cond_t res_cond;
slurmdb_init_res_cond(&res_cond, 0);
res_cond.with_clusters = 1;
g_res_list = acct_storage_g_get_res(db_conn, my_uid, &res_cond);
if (!g_res_list) {
exit_code=1;
fprintf(stderr, " Problem getting system resources "
"from database. "
"Contact your admin.\n");
FREE_NULL_LIST(name_list);
FREE_NULL_LIST(cluster_list);
slurmdb_destroy_res_rec(start_res);
return SLURM_ERROR;
}
}
res_list = list_create(slurmdb_destroy_res_rec);
itr = list_iterator_create(name_list);
if (cluster_list)
clus_itr = list_iterator_create(cluster_list);
while ((name = list_next(itr))) {
bool added = 0;
found_res = sacctmgr_find_res_from_list(
g_res_list, NO_VAL, name, start_res->server);
if (!found_res) {
if (start_res->type == SLURMDB_RESOURCE_NOTSET) {
exit_code=1;
fprintf(stderr,
" Need to designate a resource "
"type to initially add '%s'.\n", name);
break;
} else if (start_res->count == NO_VAL) {
exit_code=1;
fprintf(stderr,
" Need to designate a resource "
"count to initially add '%s'.\n", name);
break;
}
added = 1;
res = xmalloc(sizeof(slurmdb_res_rec_t));
slurmdb_init_res_rec(res, 0);
res->name = xstrdup(name);
res->description =
xstrdup(start_res->description ?
start_res->description : name);
res->manager = xstrdup(start_res->manager);
res->server = xstrdup(start_res->server);
res->count = start_res->count;
res->flags = start_res->flags;
res->type = start_res->type;
xstrfmtcat(res_str, " %s@%s\n",
res->name, res->server);
list_append(res_list, res);
}
if (cluster_list && list_count(cluster_list)) {
ListIterator found_itr = NULL;
slurmdb_clus_res_rec_t *clus_res;
char *cluster;
uint16_t start_used = 0;
if (found_res) {
found_itr = list_iterator_create(
found_res->clus_res_list);
res = xmalloc(sizeof(slurmdb_res_rec_t));
slurmdb_init_res_rec(res, 0);
res->id = found_res->id;
res->type = found_res->type;
start_used = res->percent_used =
found_res->percent_used;
}
res->clus_res_list = list_create(
slurmdb_destroy_clus_res_rec);
while ((cluster = list_next(clus_itr))) {
clus_res = NULL;
if (found_res) {
while ((clus_res =
list_next(found_itr))) {
if (!strcmp(clus_res->cluster,
cluster))
break;
}
list_iterator_reset(found_itr);
}
if (!clus_res) {
if (!added) {
added = 1;
xstrfmtcat(res_str,
" %s@%s\n", name,
res->server);
list_append(res_list, res);
}
/* make sure we don't overcommit */
res->percent_used +=
start_res->percent_used;
if (res->percent_used > 100) {
exit_code=1;
fprintf(stderr,
" Adding this %d "
"clusters to resource "
"%s@%s at %u%% each "
", with %u%% already "
"used, would go over "
"100%%. Please redo "
"your math and "
"resubmit.\n",
list_count(
cluster_list),
res->name, res->server,
start_res->percent_used,
start_used);
break;
}
clus_res = xmalloc(
sizeof(slurmdb_clus_res_rec_t));
list_append(res->clus_res_list,
clus_res);
clus_res->cluster = xstrdup(cluster);
clus_res->percent_allowed =
start_res->percent_used;
xstrfmtcat(res_str,
" Cluster - %s\t%u%%\n",
cluster,
clus_res->percent_allowed);
/* FIXME: make sure we don't
overcommit */
}
}
if (res->percent_used > 100)
break;
if (found_res)
list_iterator_destroy(found_itr);
if (!added)
slurmdb_destroy_res_rec(res);
list_iterator_reset(clus_itr);
}
}
if (cluster_list)
list_iterator_destroy(clus_itr);
list_iterator_destroy(itr);
FREE_NULL_LIST(name_list);
FREE_NULL_LIST(cluster_list);
if (exit_code) {
rc = SLURM_ERROR;
goto end_it;
}
if (!list_count(res_list)) {
printf(" Nothing new added.\n");
rc = SLURM_ERROR;
goto end_it;
}
if (res_str) {
char *tmp_str;
switch (res->type) {
case SLURMDB_RESOURCE_LICENSE:
tmp_str = "License";
break;
default:
tmp_str = "Unknown";
}
printf(" Adding Resource(s)\n%s", res_str);
printf(" Settings\n");
if (res->name)
printf(" Name = %s\n", res->name);
if (res->server)
printf(" Server = %s\n", res->server);
if (res->description)
printf(" Description = %s\n", res->description);
if (res->manager)
printf(" Manager = %s\n", res->manager);
if (res->count != NO_VAL)
printf(" Count = %u\n", res->count);
printf(" Type = %s\n", tmp_str);
xfree(res_str);
}
if (list_count(res_list)) {
notice_thread_init();
rc = acct_storage_g_add_res(db_conn, my_uid, res_list);
notice_thread_fini();
} else
goto end_it;
if (rc == SLURM_SUCCESS) {
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else {
exit_code=1;
fprintf(stderr, " Problem adding system resource: %s\n",
slurm_strerror(rc));
rc = SLURM_ERROR;
}
end_it:
FREE_NULL_LIST(res_list);
slurmdb_destroy_res_rec(start_res);
return rc;
}
extern int sacctmgr_delete_account(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_account_cond_t *acct_cond =
xmalloc(sizeof(slurmdb_account_cond_t));
int i=0;
List ret_list = NULL, local_assoc_list = NULL;
ListIterator itr = NULL;
int cond_set = 0, prev_set = 0;
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
prev_set = _set_cond(&i, argc, argv, acct_cond, NULL);
cond_set |= prev_set;
}
if (!cond_set) {
exit_code=1;
fprintf(stderr,
" No conditions given to remove, not executing.\n");
slurmdb_destroy_account_cond(acct_cond);
return SLURM_ERROR;
}
if (exit_code) {
slurmdb_destroy_account_cond(acct_cond);
return SLURM_ERROR;
}
/* check to see if person is trying to remove root account. This is
* bad, and should not be allowed outside of deleting a cluster.
*/
if (acct_cond->assoc_cond
&& acct_cond->assoc_cond->acct_list
&& list_count(acct_cond->assoc_cond->acct_list)) {
char *tmp_char = NULL;
itr = list_iterator_create(acct_cond->assoc_cond->acct_list);
while((tmp_char = list_next(itr))) {
if (!strcasecmp(tmp_char, "root"))
break;
}
list_iterator_destroy(itr);
if (tmp_char) {
exit_code=1;
fprintf(stderr, " You are not allowed to remove "
"the root account.\n"
" Use remove cluster instead.\n");
slurmdb_destroy_account_cond(acct_cond);
return SLURM_ERROR;
}
}
acct_cond->assoc_cond->only_defs = 1;
local_assoc_list = acct_storage_g_get_associations(
db_conn, my_uid, acct_cond->assoc_cond);
acct_cond->assoc_cond->only_defs = 0;
notice_thread_init();
if (cond_set == 1) {
ret_list = acct_storage_g_remove_accounts(
db_conn, my_uid, acct_cond);
} else if (cond_set & 2) {
ret_list = acct_storage_g_remove_associations(
db_conn, my_uid, acct_cond->assoc_cond);
}
rc = errno;
notice_thread_fini();
slurmdb_destroy_account_cond(acct_cond);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = NULL;
/* Check to see if person is trying to remove a default
* account of a user. _isdefault only works with the
* output from acct_storage_g_remove_accounts, and
* with a previously got assoc_list.
*/
if (_isdefault(cond_set, ret_list, local_assoc_list)) {
exit_code=1;
fprintf(stderr, " Please either remove the "
"accounts listed "
"above from list and resubmit,\n"
" or change these users default account to "
"remove the account(s).\n"
" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
goto end_it;
}
itr = list_iterator_create(ret_list);
/* If there were jobs running with an association to
be deleted, don't.
*/
if (rc == ESLURM_JOBS_RUNNING_ON_ASSOC) {
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(rc));
while((object = list_next(itr))) {
fprintf(stderr," %s\n", object);
}
acct_storage_g_commit(db_conn, 0);
goto end_it;
}
if (cond_set == 1) {
printf(" Deleting accounts...\n");
} else if (cond_set & 2) {
printf(" Deleting account associations...\n");
}
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else if (ret_list) {
printf(" Nothing deleted\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
end_it:
if (ret_list)
list_destroy(ret_list);
if (local_assoc_list)
list_destroy(local_assoc_list);
return rc;
}
extern int sacctmgr_add_account(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
int i=0;
ListIterator itr = NULL, itr_c = NULL;
slurmdb_account_rec_t *acct = NULL;
slurmdb_association_rec_t *assoc = NULL;
slurmdb_association_cond_t assoc_cond;
List name_list = list_create(slurm_destroy_char);
List cluster_list = list_create(slurm_destroy_char);
char *cluster = NULL;
char *name = NULL;
List acct_list = NULL;
List assoc_list = NULL;
List local_assoc_list = NULL;
List local_account_list = NULL;
char *acct_str = NULL;
char *assoc_str = NULL;
int limit_set = 0;
slurmdb_account_rec_t *start_acct =
xmalloc(sizeof(slurmdb_account_rec_t));
slurmdb_association_rec_t *start_assoc =
xmalloc(sizeof(slurmdb_association_rec_t));
slurmdb_init_association_rec(start_assoc, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_rec(&i, argc, argv, name_list, cluster_list,
start_acct, start_assoc);
}
if (exit_code)
return SLURM_ERROR;
if (!name_list || !list_count(name_list)) {
list_destroy(name_list);
list_destroy(cluster_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
exit_code=1;
fprintf(stderr, " Need name of account to add.\n");
return SLURM_SUCCESS;
} else {
slurmdb_account_cond_t account_cond;
memset(&account_cond, 0, sizeof(slurmdb_account_cond_t));
memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
assoc_cond.acct_list = name_list;
account_cond.assoc_cond = &assoc_cond;
local_account_list = acct_storage_g_get_accounts(
db_conn, my_uid, &account_cond);
}
if (!local_account_list) {
exit_code=1;
fprintf(stderr, " Problem getting accounts from database. "
"Contact your admin.\n");
list_destroy(name_list);
list_destroy(cluster_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
return SLURM_ERROR;
}
if (!start_assoc->parent_acct)
start_assoc->parent_acct = xstrdup("root");
if (!cluster_list || !list_count(cluster_list)) {
slurmdb_cluster_rec_t *cluster_rec = NULL;
List tmp_list =
acct_storage_g_get_clusters(db_conn, my_uid, NULL);
if (!tmp_list) {
exit_code=1;
fprintf(stderr,
" Problem getting clusters from database. "
"Contact your admin.\n");
list_destroy(name_list);
list_destroy(cluster_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
list_destroy(local_account_list);
return SLURM_ERROR;
}
if (!list_count(tmp_list)) {
exit_code=1;
fprintf(stderr,
" Can't add accounts, no cluster "
"defined yet.\n"
" Please contact your administrator.\n");
list_destroy(name_list);
list_destroy(cluster_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
list_destroy(local_account_list);
return SLURM_ERROR;
}
if (!cluster_list)
list_create(slurm_destroy_char);
else
list_flush(cluster_list);
itr_c = list_iterator_create(tmp_list);
while((cluster_rec = list_next(itr_c))) {
list_append(cluster_list, xstrdup(cluster_rec->name));
}
list_iterator_destroy(itr_c);
list_destroy(tmp_list);
} else {
List temp_list = NULL;
slurmdb_cluster_cond_t cluster_cond;
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.cluster_list = cluster_list;
temp_list = acct_storage_g_get_clusters(db_conn, my_uid,
&cluster_cond);
itr_c = list_iterator_create(cluster_list);
itr = list_iterator_create(temp_list);
while((cluster = list_next(itr_c))) {
slurmdb_cluster_rec_t *cluster_rec = NULL;
list_iterator_reset(itr);
while((cluster_rec = list_next(itr))) {
if (!strcasecmp(cluster_rec->name, cluster))
break;
}
if (!cluster_rec) {
exit_code=1;
fprintf(stderr, " This cluster '%s' "
"doesn't exist.\n"
" Contact your admin "
"to add it to accounting.\n",
cluster);
list_delete_item(itr_c);
}
}
list_iterator_destroy(itr);
list_iterator_destroy(itr_c);
list_destroy(temp_list);
if (!list_count(cluster_list)) {
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
list_destroy(local_account_list);
return SLURM_ERROR;
}
}
acct_list = list_create(slurmdb_destroy_account_rec);
assoc_list = list_create(slurmdb_destroy_association_rec);
memset(&assoc_cond, 0, sizeof(slurmdb_association_cond_t));
assoc_cond.acct_list = list_create(NULL);
itr = list_iterator_create(name_list);
while((name = list_next(itr)))
list_append(assoc_cond.acct_list, name);
list_iterator_destroy(itr);
list_append(assoc_cond.acct_list, start_assoc->parent_acct);
assoc_cond.cluster_list = cluster_list;
local_assoc_list = acct_storage_g_get_associations(
db_conn, my_uid, &assoc_cond);
list_destroy(assoc_cond.acct_list);
if (!local_assoc_list) {
exit_code=1;
fprintf(stderr, " Problem getting associations from database. "
"Contact your admin.\n");
list_destroy(name_list);
list_destroy(cluster_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
list_destroy(local_account_list);
return SLURM_ERROR;
}
itr = list_iterator_create(name_list);
while((name = list_next(itr))) {
if (!name[0]) {
exit_code=1;
fprintf(stderr, " No blank names are "
"allowed when adding.\n");
rc = SLURM_ERROR;
continue;
}
acct = NULL;
if (!sacctmgr_find_account_from_list(local_account_list, name)) {
acct = xmalloc(sizeof(slurmdb_account_rec_t));
acct->assoc_list =
list_create(slurmdb_destroy_association_rec);
acct->name = xstrdup(name);
if (start_acct->description)
acct->description =
xstrdup(start_acct->description);
else
acct->description = xstrdup(name);
if (start_acct->organization)
acct->organization =
xstrdup(start_acct->organization);
else if (strcmp(start_assoc->parent_acct, "root"))
acct->organization =
xstrdup(start_assoc->parent_acct);
else
acct->organization = xstrdup(name);
xstrfmtcat(acct_str, " %s\n", name);
list_append(acct_list, acct);
}
itr_c = list_iterator_create(cluster_list);
while((cluster = list_next(itr_c))) {
if (sacctmgr_find_account_base_assoc_from_list(
local_assoc_list, name, cluster)) {
//printf(" already have this assoc\n");
continue;
}
if (!sacctmgr_find_account_base_assoc_from_list(
local_assoc_list, start_assoc->parent_acct,
cluster)) {
exit_code=1;
fprintf(stderr, " Parent account '%s' "
"doesn't exist on "
"cluster %s\n"
" Contact your admin "
"to add this account.\n",
start_assoc->parent_acct, cluster);
continue;
}
assoc = xmalloc(sizeof(slurmdb_association_rec_t));
slurmdb_init_association_rec(assoc, 0);
assoc->acct = xstrdup(name);
assoc->cluster = xstrdup(cluster);
assoc->def_qos_id = start_assoc->def_qos_id;
assoc->parent_acct = xstrdup(start_assoc->parent_acct);
assoc->shares_raw = start_assoc->shares_raw;
assoc->grp_cpu_mins = start_assoc->grp_cpu_mins;
assoc->grp_cpu_run_mins = start_assoc->grp_cpu_run_mins;
assoc->grp_cpus = start_assoc->grp_cpus;
assoc->grp_jobs = start_assoc->grp_jobs;
assoc->grp_mem = start_assoc->grp_mem;
assoc->grp_nodes = start_assoc->grp_nodes;
assoc->grp_submit_jobs = start_assoc->grp_submit_jobs;
assoc->grp_wall = start_assoc->grp_wall;
assoc->max_cpu_mins_pj = start_assoc->max_cpu_mins_pj;
assoc->max_cpus_pj = start_assoc->max_cpus_pj;
assoc->max_jobs = start_assoc->max_jobs;
assoc->max_nodes_pj = start_assoc->max_nodes_pj;
assoc->max_submit_jobs = start_assoc->max_submit_jobs;
assoc->max_wall_pj = start_assoc->max_wall_pj;
assoc->qos_list = copy_char_list(start_assoc->qos_list);
if (acct)
list_append(acct->assoc_list, assoc);
else
list_append(assoc_list, assoc);
xstrfmtcat(assoc_str,
" A = %-10.10s"
" C = %-10.10s\n",
assoc->acct,
assoc->cluster);
}
list_iterator_destroy(itr_c);
}
list_iterator_destroy(itr);
list_destroy(local_account_list);
list_destroy(local_assoc_list);
if (!list_count(acct_list) && !list_count(assoc_list)) {
printf(" Nothing new added.\n");
rc = SLURM_ERROR;
goto end_it;
} else if (!assoc_str) {
exit_code=1;
fprintf(stderr, " No associations created.\n");
goto end_it;
}
if (acct_str) {
printf(" Adding Account(s)\n%s", acct_str);
printf(" Settings\n");
if (start_acct->description)
printf(" Description = %s\n",
start_acct->description);
else
printf(" Description = %s\n", "Account Name");
if (start_acct->organization)
printf(" Organization = %s\n",
start_acct->organization);
else
printf(" Organization = %s\n",
"Parent/Account Name");
xfree(acct_str);
}
if (assoc_str) {
printf(" Associations\n%s", assoc_str);
xfree(assoc_str);
}
if (limit_set) {
printf(" Settings\n");
sacctmgr_print_assoc_limits(start_assoc);
}
notice_thread_init();
if (list_count(acct_list))
rc = acct_storage_g_add_accounts(db_conn, my_uid, acct_list);
if (rc == SLURM_SUCCESS) {
if (list_count(assoc_list))
rc = acct_storage_g_add_associations(db_conn, my_uid,
assoc_list);
} else {
exit_code=1;
fprintf(stderr, " Problem adding accounts: %s\n",
slurm_strerror(rc));
rc = SLURM_ERROR;
notice_thread_fini();
goto end_it;
}
notice_thread_fini();
if (rc == SLURM_SUCCESS) {
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else {
exit_code=1;
fprintf(stderr,
" error: Problem adding account associations: %s\n",
slurm_strerror(rc));
rc = SLURM_ERROR;
}
end_it:
list_destroy(name_list);
list_destroy(cluster_list);
list_destroy(acct_list);
list_destroy(assoc_list);
slurmdb_destroy_association_rec(start_assoc);
slurmdb_destroy_account_rec(start_acct);
return rc;
}
extern int sacctmgr_add_federation(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
int i = 0, limit_set = 0;
slurmdb_federation_rec_t *start_fed =
xmalloc(sizeof(slurmdb_federation_rec_t));
List name_list = list_create(slurm_destroy_char);
List federation_list;
ListIterator itr = NULL;
char *name = NULL;
slurmdb_init_federation_rec(start_fed, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp(argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_rec(&i, argc, argv, name_list, start_fed);
}
if (exit_code) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_federation_rec(start_fed);
return SLURM_ERROR;
} else if (!list_count(name_list)) {
slurmdb_destroy_federation_rec(start_fed);
FREE_NULL_LIST(name_list);
fprintf(stderr, " Need name of federation to add.\n");
return SLURM_ERROR;
} else if (_remove_existing_feds(name_list)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_federation_rec(start_fed);
return SLURM_ERROR;
}
if ((list_count(name_list) > 1) &&
start_fed && start_fed->cluster_list &&
list_count(start_fed->cluster_list)) {
slurmdb_destroy_federation_rec(start_fed);
FREE_NULL_LIST(name_list);
fprintf(stderr, " Can't assign clusters to multiple "
"federations.\n");
return SLURM_ERROR;
}
if (start_fed && start_fed->cluster_list &&
list_count(start_fed->cluster_list)) {
bool existing_feds = false;
if (list_count(name_list) > 1){
slurmdb_destroy_federation_rec(start_fed);
FREE_NULL_LIST(name_list);
fprintf(stderr, " Can't assign clusters to "
"multiple federations.\n");
return SLURM_ERROR;
}
/* ensure that clusters exist in db */
/* and if the clusters are already assigned to another fed. */
if (verify_fed_clusters(start_fed->cluster_list, NULL,
&existing_feds)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_federation_rec(start_fed);
return SLURM_ERROR;
} else if (existing_feds) {
char *warning = "\nAre you sure you want to continue?";
if (!commit_check(warning)) {
FREE_NULL_LIST(name_list);
slurmdb_destroy_federation_rec(start_fed);
return SLURM_ERROR;
}
}
}
printf(" Adding Federation(s)\n");
federation_list = list_create(slurmdb_destroy_federation_rec);
itr = list_iterator_create(name_list);
while((name = list_next(itr))) {
slurmdb_federation_rec_t *fed = NULL;
if (!name[0]) {
fprintf(stderr, " Skipping blank fed name.\n");
continue;
}
fed = xmalloc(sizeof(slurmdb_federation_rec_t));
slurmdb_init_federation_rec(fed, 0);
list_append(federation_list, fed);
slurmdb_copy_federation_rec(fed, start_fed);
fed->name = xstrdup(name);
printf(" %s\n", fed->name);
}
list_iterator_destroy(itr);
FREE_NULL_LIST(name_list);
if (limit_set) {
printf(" Settings\n");
sacctmgr_print_federation(start_fed);
}
slurmdb_destroy_federation_rec(start_fed);
if (!list_count(federation_list)) {
printf(" Nothing new added.\n");
rc = SLURM_ERROR;
goto end_it;
}
notice_thread_init();
rc = acct_storage_g_add_federations(db_conn, my_uid,
federation_list);
notice_thread_fini();
if (rc == SLURM_SUCCESS) {
if (commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else {
exit_code = 1;
fprintf(stderr, " Problem adding federation(s): %s\n",
slurm_strerror(rc));
rc = SLURM_ERROR;
}
end_it:
FREE_NULL_LIST(federation_list);
return rc;
}
extern int sacctmgr_modify_federation(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
int i=0;
int cond_set = 0, prev_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
slurmdb_federation_cond_t *federation_cond =
xmalloc(sizeof(slurmdb_federation_cond_t));
slurmdb_federation_rec_t *federation =
xmalloc(sizeof(slurmdb_federation_rec_t));
slurmdb_init_federation_cond(federation_cond, 0);
slurmdb_init_federation_rec(federation, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
prev_set = _set_cond(&i, argc, argv,
federation_cond, NULL);
cond_set |= prev_set;
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
prev_set = _set_rec(&i, argc, argv, NULL, federation);
rec_set |= prev_set;
} else {
prev_set = _set_cond(&i, argc, argv,
federation_cond, NULL);
cond_set |= prev_set;
}
}
if (exit_code) {
rc = SLURM_ERROR;
goto end_it;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
rc = SLURM_ERROR;
goto end_it;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions "
"with 'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
rc = SLURM_SUCCESS;
goto end_it;
}
} else if (verify_federations_exist(
federation_cond->federation_list)) {
rc = SLURM_ERROR;
goto end_it;
}
if (federation->cluster_list) {
bool existing_feds = false;
char *mod_fed = NULL;
slurmdb_cluster_rec_t *tmp_c = NULL;
List cluster_list = federation->cluster_list;
if (federation_cond->federation_list &&
(list_count(federation_cond->federation_list) > 1)) {
fprintf(stderr, " Can't assign clusters to "
"multiple federations.\n");
rc = SLURM_ERROR;
goto end_it;
}
/* Add all clusters that need to be removed if clearing all
* clusters or add clusters that will be removed if setting
* clusters to specific set. */
mod_fed = list_peek(federation_cond->federation_list);
if ((!list_count(cluster_list) ||
((tmp_c = list_peek(cluster_list)) &&
*tmp_c->name != '-' && *tmp_c->name != '+')) &&
((rc = _add_clusters_to_remove(cluster_list, mod_fed)) ||
(rc = _change_assigns_to_adds(cluster_list)))) {
goto end_it;
} else if ((rc = verify_fed_clusters(cluster_list, mod_fed,
&existing_feds))) {
goto end_it;
} else if (!list_count(cluster_list)) {
printf("Nothing to change\n");
rc = SLURM_ERROR;
goto end_it;
} else if (existing_feds) {
char *warning = "\nAre you sure you want to continue?";
if (!commit_check(warning)) {
rc = SLURM_ERROR;
goto end_it;
}
}
}
printf(" Setting\n");
sacctmgr_print_federation(federation);
notice_thread_init();
ret_list = acct_storage_g_modify_federations(db_conn, my_uid,
federation_cond,
federation);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified federation...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
notice_thread_fini();
if (set) {
if (commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
end_it:
slurmdb_destroy_federation_cond(federation_cond);
slurmdb_destroy_federation_rec(federation);
return rc;
}
extern int sacctmgr_modify_cluster(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
int i=0;
slurmdb_association_rec_t *assoc =
xmalloc(sizeof(slurmdb_association_rec_t));
slurmdb_association_cond_t *assoc_cond =
xmalloc(sizeof(slurmdb_association_cond_t));
int cond_set = 0, prev_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
uint16_t class_rec = 0;
slurmdb_cluster_cond_t cluster_cond;
slurmdb_init_association_rec(assoc, 0);
assoc_cond->cluster_list = list_create(slurm_destroy_char);
assoc_cond->acct_list = list_create(NULL);
slurmdb_init_cluster_cond(&cluster_cond, 0);
cluster_cond.cluster_list = assoc_cond->cluster_list;
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
prev_set = _set_cond(&i, argc, argv,
&cluster_cond, NULL);
cond_set |= prev_set;
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
prev_set = _set_rec(&i, argc, argv,
NULL, assoc, &class_rec);
rec_set |= prev_set;
} else {
prev_set = _set_cond(&i, argc, argv,
&cluster_cond, NULL);
cond_set |= prev_set;
}
}
if(!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
rc = SLURM_ERROR;
goto end_it;
} else if(!cond_set) {
if(!commit_check("You didn't set any conditions with 'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
rc = SLURM_SUCCESS;
goto end_it;
}
} else if(exit_code) {
rc = SLURM_ERROR;
goto end_it;
}
if(cond_set & 1) {
List temp_list = NULL;
temp_list = acct_storage_g_get_clusters(db_conn, my_uid,
&cluster_cond);
if(!temp_list) {
exit_code=1;
fprintf(stderr,
" Problem getting clusters from database. "
"Contact your admin.\n");
rc = SLURM_ERROR;
goto end_it;
} else if(!list_count(temp_list)) {
fprintf(stderr,
" Query didn't return any clusters.\n");
rc = SLURM_ERROR;
goto end_it;
}
/* we are only looking for the clusters returned from
this query, so we free the cluster_list and replace
it */
if(assoc_cond->cluster_list)
list_destroy(assoc_cond->cluster_list);
assoc_cond->cluster_list = temp_list;
}
printf(" Setting\n");
if(rec_set) {
printf(" Default Limits =\n");
sacctmgr_print_assoc_limits(assoc);
if(class_rec)
printf(" Cluster Classification = %s\n",
get_classification_str(class_rec));
}
list_append(assoc_cond->acct_list, "root");
notice_thread_init();
ret_list = acct_storage_g_modify_associations(
db_conn, my_uid, assoc_cond, assoc);
if(ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified cluster defaults for associations...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if(ret_list) {
printf(" Nothing modified\n");
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if(ret_list)
list_destroy(ret_list);
if(class_rec) {
slurmdb_cluster_rec_t cluster_rec;
slurmdb_init_cluster_rec(&cluster_rec, 0);
/* the class has already returned these clusters so
just go with it */
cluster_rec.classification = class_rec;
ret_list = acct_storage_g_modify_clusters(
db_conn, my_uid, &cluster_cond, &cluster_rec);
if(ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified cluster classifications...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if(ret_list) {
printf(" Nothing modified\n");
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if(ret_list)
list_destroy(ret_list);
}
notice_thread_fini();
if(set) {
if(commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
end_it:
slurmdb_destroy_association_cond(assoc_cond);
slurmdb_destroy_association_rec(assoc);
return rc;
}
extern int sacctmgr_add_qos(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
int i=0, limit_set=0;
ListIterator itr = NULL;
slurmdb_qos_rec_t *qos = NULL;
slurmdb_qos_rec_t *start_qos = xmalloc(sizeof(slurmdb_qos_rec_t));
List name_list = list_create(slurm_destroy_char);
char *description = NULL;
char *name = NULL;
List qos_list = NULL;
char *qos_str = NULL;
slurmdb_init_qos_rec(start_qos, 0);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp (argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp (argv[i], "Set", MAX(command_len, 3)))
i++;
limit_set += _set_rec(&i, argc, argv, name_list, start_qos);
}
if(exit_code) {
list_destroy(name_list);
xfree(description);
return SLURM_ERROR;
} else if(!list_count(name_list)) {
list_destroy(name_list);
slurmdb_destroy_qos_rec(start_qos);
exit_code=1;
fprintf(stderr, " Need name of qos to add.\n");
return SLURM_SUCCESS;
}
if(!g_qos_list) {
g_qos_list = acct_storage_g_get_qos(db_conn, my_uid, NULL);
if(!g_qos_list) {
exit_code=1;
fprintf(stderr, " Problem getting qos's "
"from database. "
"Contact your admin.\n");
list_destroy(name_list);
xfree(description);
return SLURM_ERROR;
}
}
qos_list = list_create(slurmdb_destroy_qos_rec);
itr = list_iterator_create(name_list);
while((name = list_next(itr))) {
qos = NULL;
if(!sacctmgr_find_qos_from_list(g_qos_list, name)) {
qos = xmalloc(sizeof(slurmdb_qos_rec_t));
slurmdb_init_qos_rec(qos, 0);
qos->name = xstrdup(name);
if(start_qos->description)
qos->description =
xstrdup(start_qos->description);
else
qos->description = xstrdup(name);
qos->grace_time = start_qos->grace_time;
qos->grp_cpu_mins = start_qos->grp_cpu_mins;
qos->grp_cpus = start_qos->grp_cpus;
qos->grp_jobs = start_qos->grp_jobs;
qos->grp_mem = start_qos->grp_mem;
qos->grp_nodes = start_qos->grp_nodes;
qos->grp_submit_jobs = start_qos->grp_submit_jobs;
qos->grp_wall = start_qos->grp_wall;
qos->max_cpu_mins_pj = start_qos->max_cpu_mins_pj;
qos->max_cpu_run_mins_pu =
start_qos->max_cpu_run_mins_pu;
qos->max_cpus_pj = start_qos->max_cpus_pj;
qos->max_cpus_pu = start_qos->max_cpus_pu;
qos->max_jobs_pu = start_qos->max_jobs_pu;
qos->max_nodes_pj = start_qos->max_nodes_pj;
qos->max_nodes_pu = start_qos->max_nodes_pu;
qos->max_submit_jobs_pu = start_qos->max_submit_jobs_pu;
qos->max_wall_pj = start_qos->max_wall_pj;
qos->preempt_list =
copy_char_list(start_qos->preempt_list);
qos->preempt_mode = start_qos->preempt_mode;
qos->priority = start_qos->priority;
qos->usage_factor = start_qos->usage_factor;
qos->usage_thres = start_qos->usage_thres;
xstrfmtcat(qos_str, " %s\n", name);
list_append(qos_list, qos);
}
}
list_iterator_destroy(itr);
list_destroy(name_list);
if (g_qos_list) {
list_destroy(g_qos_list);
g_qos_list = NULL;
}
if(!list_count(qos_list)) {
printf(" Nothing new added.\n");
goto end_it;
}
if(qos_str) {
printf(" Adding QOS(s)\n%s", qos_str);
printf(" Settings\n");
if(description)
printf(" Description = %s\n", description);
else
printf(" Description = %s\n", "QOS Name");
sacctmgr_print_qos_limits(start_qos);
xfree(qos_str);
}
notice_thread_init();
if(list_count(qos_list))
rc = acct_storage_g_add_qos(db_conn, my_uid, qos_list);
else
goto end_it;
notice_thread_fini();
if(rc == SLURM_SUCCESS) {
if(commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else {
exit_code=1;
fprintf(stderr, " Problem adding QOS: %s\n",
slurm_strerror(rc));
rc = SLURM_ERROR;
}
end_it:
list_destroy(qos_list);
xfree(description);
return rc;
}
extern int sacctmgr_delete_qos(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_qos_cond_t *qos_cond =
xmalloc(sizeof(slurmdb_qos_cond_t));
int i=0;
List ret_list = NULL;
int set = 0;
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp (argv[i], "Where", MAX(command_len, 5))
|| !strncasecmp (argv[i], "Set", MAX(command_len, 3)))
i++;
set += _set_cond(&i, argc, argv, qos_cond, NULL);
}
if(!set) {
exit_code=1;
fprintf(stderr,
" No conditions given to remove, not executing.\n");
slurmdb_destroy_qos_cond(qos_cond);
return SLURM_ERROR;
} else if(set == -1) {
slurmdb_destroy_qos_cond(qos_cond);
return SLURM_ERROR;
}
if (!g_qos_list)
g_qos_list = acct_storage_g_get_qos(
db_conn, my_uid, NULL);
notice_thread_init();
ret_list = acct_storage_g_remove_qos(db_conn, my_uid, qos_cond);
notice_thread_fini();
slurmdb_destroy_qos_cond(qos_cond);
if(ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = NULL;
/* Check to see if person is trying to remove a default
* qos of an association. _isdefault only works with the
* output from acct_storage_g_remove_qos, and
* with a previously got g_qos_list.
*/
if (_isdefault(ret_list)) {
exit_code=1;
fprintf(stderr, " Please either remove the qos' listed "
"above from list and resubmit,\n"
" or change the default qos to "
"remove the qos.\n"
" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
goto end_it;
}
itr = list_iterator_create(ret_list);
printf(" Deleting QOS(s)...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
if(commit_check("Would you like to commit changes?")) {
acct_storage_g_commit(db_conn, 1);
} else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
} else if(ret_list) {
printf(" Nothing deleted\n");
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
end_it:
if(ret_list)
list_destroy(ret_list);
return rc;
}
extern int sacctmgr_modify_qos(int argc, char *argv[])
{
int rc = SLURM_SUCCESS;
slurmdb_qos_cond_t *qos_cond = xmalloc(sizeof(slurmdb_qos_cond_t));
slurmdb_qos_rec_t *qos = xmalloc(sizeof(slurmdb_qos_rec_t));
int i=0;
int cond_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
slurmdb_init_qos_rec(qos, 0, NO_VAL);
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
cond_set += _set_cond(&i, argc, argv, qos_cond, NULL);
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
rec_set += _set_rec(&i, argc, argv, NULL, qos);
} else {
cond_set += _set_cond(&i, argc, argv, qos_cond, NULL);
}
}
if (exit_code) {
slurmdb_destroy_qos_cond(qos_cond);
slurmdb_destroy_qos_rec(qos);
return SLURM_ERROR;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
slurmdb_destroy_qos_cond(qos_cond);
slurmdb_destroy_qos_rec(qos);
return SLURM_ERROR;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions with 'WHERE'.\n"
"Are you sure you want to continue?")) {
printf("Aborted\n");
slurmdb_destroy_qos_cond(qos_cond);
slurmdb_destroy_qos_rec(qos);
return SLURM_SUCCESS;
}
}
// Special case: reset raw usage only
if (qos->usage) {
rc = SLURM_ERROR;
if (qos->usage->usage_raw == 0.0)
rc = sacctmgr_remove_qos_usage(qos_cond);
else
error("Raw usage can only be set to 0 (zero)");
slurmdb_destroy_qos_cond(qos_cond);
slurmdb_destroy_qos_rec(qos);
return rc;
}
notice_thread_init();
ret_list = acct_storage_g_modify_qos(db_conn, my_uid, qos_cond, qos);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified qos...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
if (ret_list)
list_destroy(ret_list);
notice_thread_fini();
if (set) {
if (commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
slurmdb_destroy_qos_cond(qos_cond);
slurmdb_destroy_qos_rec(qos);
return rc;
}
extern int sacctmgr_modify_job(int argc, char **argv)
{
int rc = SLURM_SUCCESS;
slurmdb_job_modify_cond_t *job_cond = xmalloc(sizeof(
slurmdb_job_modify_cond_t));
slurmdb_job_rec_t *job = slurmdb_create_job_rec();
int i=0;
int cond_set = 0, rec_set = 0, set = 0;
List ret_list = NULL;
for (i=0; i<argc; i++) {
int command_len = strlen(argv[i]);
if (!strncasecmp(argv[i], "Where", MAX(command_len, 5))) {
i++;
cond_set += _set_cond(&i, argc, argv, job_cond);
} else if (!strncasecmp(argv[i], "Set", MAX(command_len, 3))) {
i++;
rec_set += _set_rec(&i, argc, argv, job);
} else {
cond_set += _set_cond(&i, argc, argv, job_cond);
}
}
if (exit_code) {
slurmdb_destroy_job_modify_cond(job_cond);
slurmdb_destroy_job_rec(job);
return SLURM_ERROR;
} else if (!rec_set) {
exit_code=1;
fprintf(stderr, " You didn't give me anything to set\n");
slurmdb_destroy_job_modify_cond(job_cond);
slurmdb_destroy_job_rec(job);
return SLURM_ERROR;
} else if (!cond_set) {
if (!commit_check("You didn't set any conditions with 'WHERE'."
"\nAre you sure you want to continue?")) {
printf("Aborted\n");
slurmdb_destroy_job_modify_cond(job_cond);
slurmdb_destroy_job_rec(job);
return SLURM_SUCCESS;
}
}
notice_thread_init();
ret_list = acct_storage_g_modify_job(db_conn, my_uid, job_cond, job);
if (ret_list && list_count(ret_list)) {
char *object = NULL;
ListIterator itr = list_iterator_create(ret_list);
printf(" Modified jobs...\n");
while((object = list_next(itr))) {
printf(" %s\n", object);
}
list_iterator_destroy(itr);
set = 1;
} else if (ret_list) {
printf(" Nothing modified\n");
rc = SLURM_ERROR;
} else {
exit_code=1;
fprintf(stderr, " Error with request: %s\n",
slurm_strerror(errno));
rc = SLURM_ERROR;
}
FREE_NULL_LIST(ret_list);
notice_thread_fini();
if (set) {
if (commit_check("Would you like to commit changes?"))
acct_storage_g_commit(db_conn, 1);
else {
printf(" Changes Discarded\n");
acct_storage_g_commit(db_conn, 0);
}
}
slurmdb_destroy_job_modify_cond(job_cond);
slurmdb_destroy_job_rec(job);
return rc;
}